需要理解并记住的几个c++要点和难点

最新推荐文章于 2024-06-09 05:15:00 发布

taosinker

最新推荐文章于 2024-06-09 05:15:00 发布

阅读量2.7k

点赞数

CC 4.0 BY-SA版权

文章标签： c++ buffer class 编译器语言 object

本文链接：https://blog.youkuaiyun.com/taosinker/article/details/2109989

本文深入探讨C++中的拷贝构造函数与赋值函数调用时机、对象布局模型、类成员访问控制等内容，通过实例帮助读者更好地理解C++的底层机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

引子

全球有几百万人在使用c++,可是能称得上专家的没有几个。大多数人还是仅仅是为了解决自己领域内的问题而了解一下c++,仅仅使用了C++语言中一部分子集，有许多问题并不清楚。可是既然吃定了IT业这碗饭了，特别是经常用C++作为工作语言的工程师，很好的掌握C++是一个基本功。C++的语言要点很多，我在学习C++的过程中总结了一些需要引起重视的地方以及收集了几个难点，希望对学习C++的同志有所帮助。这篇文章会动态地变化。

声明和定义的位置
C++的名字解释
内存对象模型
安全编程

本文将分阶段完成。

1）什么时候调用拷贝构造函数与拷贝赋值函数？

当要在创建一个类对象并用一个存在的对象初始化该对象时（包括直接定义的类对象以及在函数中的临时类对象）拷贝构造函数将被调用。当用一个对象向另一个对象赋值是，如果存在拷贝赋值函数的定义时，就会调用拷贝赋值函数。这些规则很简单，可是大家看下面的例子，猜猜那个函数会被调用。

class ABC{

public:

ABC& ABC(const ABC& abc){...};

ABC& operator=(const ABC& abc){...};

}

ABC one;

ABC two=one; //什么函数会被调用?

ABC three;

three=two; //什么函数会被调用?

答案是： ABC two=one; 在这种情况下是由于要创建对象two会调用拷贝构造函数 ABC(const ABC&)。three=two会调用赋值函数 operator=(const ABC&)。

2. C++的对象布局

冯.诺依曼计算机是按指令一条条执行的，如何实现出C++面向对象及范型编程的特性，这是编译器要做的工作。在C++编译器内部都有个C++对象模型，各家的编译器可能有所不同，但是大同小异。这个对象模型，其实就是C++的对象布局模型，它规定了C++类变量及成员如何布置。C++编译器便在其定义的对象模型的基础上，对C++语言按照此模型进行展开（展开成C或者有其他中间语言，最后成为机器语言），在编译时或运行时对C++的对象操作进行支持。

查看下面的例子：

//============================================================================

#include <iostream>

#include <string>

#include <typeinfo>

using namespace std;

//根类

class Base{

int a;

public:

string discription;

//缺省构造函数

Base(void){

discription="Class Base";

printDisp();

a=1;

};

Base(Base&h){a=1;};//赋值函数

virtual ~Base(void){};

virtual void printDisp(void){cout<<discription<<endl;};

virtual void f(int){printf("Base::f");}; //虚函数

};

class DerivedOne:public Base{

public:

int done;

DerivedOne(void):Base()

{

discription="Class DerivedOne";

printDisp();

done=3;

};

virtual ~DerivedOne(){};

void f(void){printf("DerivedOne::f");}; //虚函数实现覆盖

virtual void g(void){f();}; //定义一个新的虚函数

};

class DerivedTwo:public Base{

int c;

public:

DerivedTwo(void){c=3;};

virtual ~DerivedTwo(){};

virtual void h(int){};

};

// 多重继承

class DerivedThree:public DerivedOne,public DerivedTwo{

int d;

public:

DerivedThree(void){d=4;};

~DerivedThree(){};

void f(int){printf("DerivedThree::f");};

};

int main(int argc, char* argv[])

{

int ss;

Base base;

DerivedOne one;

DerivedThree three;

DerivedOne* pone=&one;

pone->g();

cin>>ss;

}

eclipse 编译完成后可以很容易看见对象的内存布局。

base的内存布局是

{_vptr$Base = 0x444d8c, a = 1, discription = {static npos = 4294967295, _M_dataplus = {<allocator<char>> = {<new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x7127dc "Class Base"}}}

virtual table pointer

_vptr$Base

Base Data

a=1;

discription={...}

{<Base> = {_vptr$Base = 0x444d0c, a = 1, discription = {static npos = 4294967295, _M_dataplus = {<allocator<char>> = {<new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x722824 "Class DerivedOne"}}}, done = 3}

从中可以看出，如果一个类有虚函数那该对象会有一个虚函数表指针在数据布局中。

one的内存布局是：

Base Class data

_vptr$Base = ...... ;

a=1;

discription = "";

DrivedOne data

done = 3;

一个对象构造时会先构造好基类的对象数据布局然后再构造自身的数据。

three的对象内存布局是：

{<DerivedOne> = {<Base> = {_vptr$Base = 0x22c9d8, a = 7405568, discription = {static npos = 4294967295, _M_dataplus = {<allocator<char>> = {<new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x22ce68 "/340/377/""}}}, done = 88}, <DerivedTwo> = {<Base> = {_vptr$Base = 0x270f0050, a = 0, discription = {static npos = 4294967295, _M_dataplus = {<allocator<char>> = {<new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x7 <Address 0x7 out of bounds>}}}, c = 5177344}, d = 5242904}

DrivedOne

Base object;

done = ...;

DrivedTwo

Base object;

c = ...;

大家可以看见，对象three有两个Base Object实例，为了避免这种情况，我们需要利用虚继承。将DerivedOne 和DerivedTwo改写代码如下：

class DerivedOne:public virtual Base{...};

class DerivedTwo:public virtual Base{...};

可以看到three的对象布局为：

{<DerivedOne> = {<Base> = {_vptr$Base = 0x445eb4, a = 1, discription = {static npos = 4294967295, _M_dataplus = {<allocator<char>> = {<new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x72284c "Class DerivedOne"}}}, _vptr$DerivedOne = 0x445e78, done = 3}, <DerivedTwo> = {_vptr$DerivedTwo = 0x445e94, c = 3}, d = 4}

你可以很明显地看到，只有一个Base object.