虚成员变量？！

最新推荐文章于 2022-09-25 12:09:35 发布
原创 最新推荐文章于 2022-09-25 12:09:35 发布 · 4.8k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#class #c++ #c

本文通过一个具体的C++代码示例，展示了当基类和派生类中存在同名成员变量时可能出现的问题。强调了这与虚函数的多态行为不同，并提醒开发者要注意变量隐藏的现象。
部署运行你感兴趣的模型镜像

 【原文写于2005年5月4日03:11星期三，注】

“虚成员变量”？！
注意！！没有“虚成员变量”，C++不会帮你多态
所以，如果在基类和派生类中定义了命名一样的成员变量，就要十分小心了

代码

#include
using namespace std ;

class A
{
public:
A() { m_c = 'A' ; }
char m_c ;
} ;

class B : public A
{
public:
B() { m_c = 'B' ; }
char m_c ;
} ;

int main()
{
A a ;
B b ;

A * p = &b ;
cout << p->m_c << endl ;
cout << ((B*)p)->m_c << endl ;
return 0 ;
}

/************输出***************/
A
B


派生类中保存了自己的成员变量和基类的成员变量，具体引用哪个，根据类型决定
这与虚函数是完全不同的

您可能感兴趣的与本文相关的镜像

ACE-Step

ACE-Step

音乐合成
ACE-Step

ACE-Step是由中国团队阶跃星辰（StepFun）与ACE Studio联手打造的开源音乐生成模型。 它拥有3.5B参数量，支持快速高质量生成、强可控性和易于拓展的特点。 最厉害的是，它可以生成多种语言的歌曲，包括但不限于中文、英文、日文等19种语言

C++用虚基类来避免成员变量或成员方法调用的二义性问题
田野麦子
04-09 830
注意： 若在继承时不将Vehicle类声明为虚基类，则在对象mc调用Vehicle类中的成员变量或成员方法时就会产生二义性。因为编译器不知道该成员变量或成员方法是来自Bicycle类还是来自Motorcar类。 /*----------------------------------------------------- 功能：用虚基类来避免成员函数或成员方法调用的二义性问题 运行结果： 60 1...
C++中的“虚”
陈云佳的专栏
01-07 1849
本博文整理的知识点是C++中有关虚的一切，包括：虚函数，纯虚函数，纯虚类（抽象类），虚基类，虚析构函数、虚基类、虚继承、虚函数表… 1.什么是虚函数，有什么作用？ 前言 先理解多态：http://blog.youkuaiyun.com/BillCYJ/article/details/79523110，磨刀不误砍柴功。 若派生类内定义了一个与基类同名的成员函数（假设是非虚函数的成员函数），该现象称为...
C++虚函数、静态变量
shuxingcq的博客
03-09 1083
虚函数是在类中被声明为virtual的成员函数，当编译器看到通过指针或引用调用此类函数时，对其执行动态联编，即通过指针（或引用）指向的类的类型信息来决定该函数是哪个类的。通常此类指针或引用都声明为基类的，它可以指向基类或派生类的对象。多态指同一个方法根据其所属的不同对象可以有不同的行为。 虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数 1
c++虚函数、成员变量内存布局
杨文海的专栏
07-19 3752
大家都知道c++的虚函数有个虚表，那这个需要具体在哪呢，在程序的代码段还是数据段的？一个类有成员变量，成员变量在代码段内是怎么分布的呢？ 如何根据一个对象指针调用某个虚函数？如何根据一个对象的指针直接修改成员变量？如果生成多个对象，那是不是会为每一个对象都生成一份虚表？ ok，问了这么多，咱们来一一解答吧。虚表其实在数据段。对于一个具体类型来说，它的行为是确定的，即对于同一个类型的所有
虚成员
weixin_30834019的博客
07-20 267
虚成员就是其声明中在返回类型前面带有关键字“virtual”的类成员函数。 C++中基类通过将成员函数指定为虚函数来指出希望派生类重定义的那些函数。 除了构造函数外，任意非static函数都可以为虚成员。 转载于:https://www.cnblogs.com/qiushuixiaozhanshi/p/5687064.html...
虚成员(virtual)
weixin_30448603的博客
08-16 166
class Program { class BaseClass { public virtual void OutPut() { Console.WriteLine("我是基类方法"); } } ...
精选资源
C++静态成员变量和静态成员函数
01-21
静态成员变量和静态成员函数 class ClassA { int a; int b; static int c; //静态成员变量 static void xxx_fun() //静态成员函数 { ... } } 普通成员变量每个对象都有各自的一份，静态成员变量所有对象...
C++空类及没有成员变量的类的大小实例分析
09-04
总结来说，C++中空类和无成员变量的类的大小并不是简单的0字节，而是受到编译器实现、虚函数以及内存对齐规则的影响。了解这些概念有助于我们更好地理解类的内存布局和C++的对象模型。在实际编程中，这些细节可能会...
详解C++编程中类的成员变量和成员函数的相关知识
09-03
在C++编程中，类是面向对象编程的基础，它封装了数据（成员变量）和操作这些数据的方法（成员函数）。类的成员变量是类实例的一部分，它们存储对象的状态信息。成员函数则是对类实例进行操作的函数，它们定义了对象...
C++学习20 虚基类详解
dengaoxin0873的博客
08-26 268
多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如非常经典的菱形继承层次。如下图所示： 类A派生出类B和类C，类D继承自类B和类C，这个时候类A中的成员变量和成员函数继承到类D中变成了两份，一份来自 A-->B-->D 这一路，另一份来自 A-->C-->D 这一条路。 在一个派生类中...
C++纯虚类
swsgdhr的专栏
03-24 984
1.含有一个纯虚函数的类是纯虚类2.纯虚类可以有成员变量3.纯虚类可以有普通的成员函数（包括普通成员函数和虚拟成员函数）3.纯虚类可不可以又带有参数的构造函数？ (可以)4.可不可以在纯虚类的派生类的构造函数中显式调用纯虚类的带参数构造函数(可以)
C++虚成员函数
qq_28938511的博客
02-14 297
和普通的成员函数一样，虚成员函数同样可以被继承。我们只需要将基类中的display函数通过virtual关键字声明为虚函数，之后即使在派生类中display函数声明时未加上virtual关键字，但它在所有的派生类中都将自动成为虚函数。 #include<iostream> using namespace std; class base { public: virtual ...
C++虚成员函数表vtable
weixin_34006965的博客
09-23 194
介绍一下多态是如何实现的，关于如何实现多态，对于程序设计人员来说即使不知道也是完全没有关系的，但是对于加深对多态的理解具有重要意义，故而在此节中稍微阐述一下多态的实现机制。在C++中通过虚成员函数表vtable实现多态，虚函数表中存储的是类中虚函数的入口地址。在普通的类中是没有虚函数表的，只有在具有虚函数的类中（无论是自身添加的虚函数还是继承过来的虚函数）才会具有虚函数表，通常虚成员函数表的首地址...
C++类的虚成员函数
peng_shakalaka的博客
04-19 4392
一、简介 虚函数就是类的成员函数前面加上virtual关键字的函数。虚函数的作用就是为了实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略。使用了virtual程序将根据引用或指针指向的类型来选择方法，如果没有使用virtual程序将根据指针类型或引用类型来选择方法。二、虚函数简单演示 在多态
C++基础(3)（成员变量）
weixin_43701339的博客
11-18 260
#C++基本知识 —————————— 知识点总结： 在c++中，由就近原则，当全局变量和成员变量叫法一样时，用成员变量 local variable 本地变量/局部变量（=parameter）。离开了函数就不存在 类是虚的，只有实体（对象）才有变量，类只是申明变量，并不拥有变量 函数是类的，不是属于对象的 所有的成员函数都有一个hidden parameter，叫this ...
类中普通函数，虚函数，成员变量互相存在时的内存占用
yudaowang的博客
09-25 675
对比观看可以知道，由于内存中数据对齐，成员变量的大小为12。B类的大小也是12，显然此时系统没有计算普通函数的大小，实际上在内存中普通成员函数是不占内存空间的，但是可以看到C类的大小为1，这又是为什么呢？在C++中，类中只有普通函数的情况下，由于类是可以实例化的，内存需要分配一个内存地址来区分该实例化。对于虚函数会建立一个虚函数表，对应的内存中会有一个虚函数指针vptr占用4字节。A中包含普通函数，虚函数，两个int类型成员变量和一个char型成员变量；B中包含普通函数，成员变量（成员变量与A一致）；
C++中的各种“虚“-- 虚函数、纯虚函数、虚继承、虚基类、虚析构、纯虚析构、抽象类讲解
weixin_47826078的博客
07-29 1636
C++中的一些重要概念都与“虚”相关，比如： ① 虚基类、虚继承、虚基类指针（vbptr）、虚基类表（vbtable）； ② 虚函数、纯虚函数、虚函数指针（vfptr）、虚函数表（vftable）、抽象类、虚析构、纯虚析构。 这里对上面罗列出的概念做一个总结，争取把这些都一次讲清楚：......
python 类函数 成员函数_Python中类的成员函数都是虚函数
weixin_39802969的博客
02-19 207
这里有篇文章：http://blog.youkuaiyun.com/guocongbin/article/details/71894，没写到点子上。应该这样来看：class A:def f(self):print("Af")def g(self):self.f()class B(A):def f(self):print("Bf")b=B()b.g()输出：Bf成员变量都是“虚”的：class A:def __...
C++ 虚指针、成员变量与类对象的偏移地址
weixin_34248849的博客
06-01 281
先给出一段代码实现 #include &lt;iostream&gt; using namespace std; class animal { protected: int age; public: virtual void print_age(void) = 0; }; class dog : public animal { public: dog() {...
这个代码适不适合在头文件就定义成员变量？什么项目适合在头文件定义成员变量
最新发布
09-19
<think> 我们讨论的是C++中的类设计问题。在C++中，类的成员变量可以在头文件中定义，但需要考虑一些设计原则和潜在问题。 关键点： 1. 头文件通常用于声明，而定义通常在源文件中（对于非模板类）。 2. 在头文件中定义成员变量会导致的问题： - 暴露实现细节：头文件是公开的，任何包含该头文件的代码都能看到类的私有成员（尽管有访问控制，但可见性仍然存在）。 - 编译依赖：如果成员变量的类型发生变化，所有包含该头文件的代码都需要重新编译。 - 内联函数：在头文件中定义的成员函数默认为内联的，但成员变量本身不涉及内联，只是可见性问题。 3. 适合在头文件中定义成员变量的情况： - 模板类：由于模板必须在头文件中实现，因此成员变量也必须定义在头文件中。 - 纯头文件的库（Header-only libraries）：为了简化分发和使用，整个类实现都在头文件中。 - 小型工具类或简单的数据结构（如POD结构），这些类不太可能改变，并且需要被多个源文件包含。 4. 不适合的情况： - 大型项目中的核心类：为了减少编译依赖和封装实现细节，通常使用Pimpl惯用法或其他技术来隐藏成员变量。 - 当成员变量类型很大或复杂时，会拖慢编译速度。 下面我们用代码示例来说明： 示例1：在头文件中定义成员变量（通常做法） ```cpp // MyClass.h class MyClass { private: int m_value; // 在头文件中定义成员变量 public: MyClass(int value); void print() const; }; ``` 示例2：使用Pimpl惯用法隐藏成员变量（减少编译依赖） ```cpp // MyClass.h class MyClass { public: MyClass(int value); ~MyClass(); void print() const; private: struct Impl; // 前向声明 Impl* pImpl; // 只暴露一个指针，隐藏具体实现 }; // MyClass.cpp #include "MyClass.h" #include <iostream> struct MyClass::Impl { int m_value; }; MyClass::MyClass(int value) : pImpl(new Impl{value}) {} MyClass::~MyClass() { delete pImpl; } void MyClass::print() const { std::cout << pImpl->m_value << std::endl; } ``` 总结： 在头文件中定义成员变量是常见的，特别是对于一些小型类或模板类。但是，在大型项目中，为了减少编译依赖和隐藏实现细节，我们倾向于将实现细节放在源文件中（如使用Pimpl惯用法）。此外，如果成员变量的类型可能会频繁变化，那么将其放在头文件中会导致大量的重新编译。 因此，适合在头文件中定义成员变量的项目包括： - 小型项目，编译速度不是问题。 - 纯头文件的库（如Eigen，GLM等数学库）。 - 模板类。 而以下情况则不适合： - 大型项目，特别是那些需要长时间编译的项目。 - 库的开发，为了保持二进制兼容性（改变成员变量会破坏二进制兼容性）。 - 需要隐藏实现细节的场合（如商业库）。 §§相关问题§§: 1. Pimpl惯用法的具体实现原理是什么？ 2. 在头文件中定义成员变量如何影响编译时间？ 3. 如何设计一个纯头文件的库（Header-only library）？ 4. 在C++中，如何实现二进制兼容性？ </think> # 在头文件中定义成员变量的适用场景分析 在C++项目开发中，决定是否在头文件中定义成员变量是一个重要的设计决策。这取决于项目的规模、架构和维护需求。让我们详细分析什么情况下适合在头文件中定义成员变量。 ## 不适合在头文件中定义成员变量的情况 ```cpp // MyClass.h（不推荐的方式） class MyClass { public: MyClass(int val) : value(val) {} int getValue() const { return value; } private: int value; // 在头文件中定义成员变量 }; ``` ### 为什么不推荐 1. **编译依赖性**： - 修改头文件会导致所有包含该头文件的源文件重新编译 - 在大型项目中，这会显著增加编译时间 2. **封装破坏**： - 暴露实现细节，破坏了类的封装性 - 使用者可能依赖于内部实现，增加维护成本 3. **二进制兼容性问题**： - 更改成员变量布局会破坏二进制兼容性 - 需要重新编译所有依赖组件 4. **耦合度高**： - 头文件包含关系变得复杂 - 增加循环依赖的风险 ## 适合在头文件中定义成员变量的情况 ### 1. 模板类和头文件库 ```cpp // Vector.h（适合的情况） template <typename T> class Vector { public: Vector(size_t capacity = 10) : size_(0), capacity_(capacity), data_(new T[capacity]) {} ~Vector() { delete[] data_; } void push_back(const T& value) { if (size_ >= capacity_) resize(); data_[size_++] = value; } private: size_t size_; size_t capacity_; T* data_; // 在头文件中定义 void resize() { capacity_ *= 2; T* new_data = new T[capacity_]; std::copy(data_, data_ + size_, new_data); delete[] data_; data_ = new_data; } }; ``` **适用项目**： - 纯头文件库（如Eigen、GLM等数学库） - 模板类（必须在使用处实例化） - 小型通用工具类 ### 2. 小型项目或原型开发 ```cpp // Point.h（小型项目适用） class Point { public: Point(double x, double y) : x_(x), y_(y) {} double distanceTo(const Point& other) const { double dx = x_ - other.x_; double dy = y_ - other.y_; return std::sqrt(dx*dx + dy*dy); } private: double x_; // 在头文件中定义 double y_; // 在头文件中定义 }; ``` **适用项目**： - 小型应用程序（<10个文件） - 快速原型开发 - 教学示例代码 ### 3. 性能关键的嵌入式系统 ```cpp // SensorReader.h（嵌入式系统适用） class SensorReader { public: SensorReader() : last_reading(0), calibration_factor(1.0f) {} float read() { // 直接访问硬件寄存器 last_reading = *reinterpret_cast<volatile float*>(0x4000C000); return last_reading * calibration_factor; } private: volatile float last_reading; // 内存映射IO访问 float calibration_factor; // 校准因子 }; ``` **适用项目**： - 资源受限的嵌入式系统 - 需要避免虚函数调用的场景 - 内存布局必须精确控制的系统 ## 最佳实践：Pimpl惯用法（推荐方式） ```cpp // MyClass.h（推荐方式） class MyClassImpl; // 前向声明 class MyClass { public: MyClass(int value); ~MyClass(); int getValue() const; void setValue(int value); private: std::unique_ptr<MyClassImpl> pImpl; // 只在头文件中暴露指针 }; ``` ```cpp // MyClass.cpp class MyClassImpl { public: MyClassImpl(int val) : value(val) {} int value; }; MyClass::MyClass(int value) : pImpl(std::make_unique<MyClassImpl>(value)) {} MyClass::~MyClass() = default; int MyClass::getValue() const { return pImpl->value; } void MyClass::setValue(int value) { pImpl->value = value; } ``` ### Pimpl的优势 1. **降低编译依赖**：修改实现不影响头文件 2. **保持二进制兼容性**：实现变化不影响接口 3. **隐藏实现细节**：更好的封装性 4. **减少头文件包含**：加快编译速度 ## 决策指南：何时在头文件中定义成员变量 | 项目类型 | 适合头文件定义 | 推荐解决方案 | |----------|----------------|--------------| | 大型商业应用 | ❌ 不适合 | Pimpl惯用法 | | 模板库/头文件库 | ✅ 适合 | 直接定义 | | 小型工具/脚本 | ✅ 适合 | 直接定义 | | 嵌入式系统 | ⚠️ 有条件适合 | 直接定义（需考虑内存布局） | | 跨平台SDK | ❌ 不适合 | Pimpl或接口类 | | 原型/演示代码 | ✅ 适合 | 直接定义 | ## 总结 在头文件中定义成员变量适合： 1. **纯头文件库和模板类**（技术上必须） 2. **小型项目或原型**（简化开发） 3. **嵌入式系统**（需要精确内存布局） 在以下情况应避免： 1. 大型商业项目 2. 需要保持二进制兼容性的库 3. 要求低编译依赖性的系统 对于大多数项目，**Pimpl惯用法**是最佳选择，它提供了良好的封装性、编译隔离和二进制兼容性，同时保持了代码的灵活性。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值