C++细节总结

最新推荐文章于 2024-07-29 09:59:43 发布

Alexander_Frank

最新推荐文章于 2024-07-29 09:59:43 发布

阅读量513

点赞数

分类专栏： C++ 文章标签： C++

本文链接：https://blog.csdn.net/Alexander_Frank/article/details/50858470

版权

C++ 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

在C++的编程过程中，我遇见了C++中许多一般不为人所知的细节，或是小技巧。以下总结出来希望对大家编程有帮助。

当我们进行编译的时候，要使用一系列的工具，我们称之为工具链，其中包括:
预处理器cpp
编译器gcc/g++
汇编器as
链接器ld
一个C/C++程序编译过程包括下面几个阶段：
预处理   预处理器cpp将对源文件中的宏进行展开。
编译    gcc将c文件编译成汇编文件。
汇编    汇编器as将汇编文件编译成机器码。
链接    链接器ld将目标文件和外部符号进行连接，得到一个可执行二进制文件。

void*指针的使用:

void型指针，

void型指针可以用来接收任何类型的指针的值，

如

int* p=&a;

void* q=p;

但是void型包容任何其他类型，但其它任何类型不包容它。

如

void* p;

float* q=(float*)p;

但是就算强制转换void型也只能转换成它指向的类型。

float* q;

void* p=q;

(int *)p;-------错误，p只能转换成float*

const的使用：

const int *p;

声明的是一个指向const int型的指针，指针本身不是const类型，所以我们可以更改该指针的指向，但不能通过指针来改变指向的对象的值，但可以直接修改指向的值。

int * const p;

声明的是一个指向int型的const型指针，不能更改指针的指向，但该指针指向的对象不是const类型，所以可以直接使用指针来更改对象的值。

当const 出现在函数的形参和返回值上时，也如以上一样判断。

const int* fun(); 返回值指针所指向常量

int* const fun(); 返回值指针为常量

const修饰成员函数时：

class A{

void fun() const;

};

fun()函数既不能调用类中非const成员函数也不能调用const成员变量，与静态static用法一致。

关键字 explicit 可防止隐式转换，使用该关键字修饰的变量不能隐式转换。

如:

class myclass

{

public: myclass(int num);

}

myclass A=10; 编译通过等价于 myclass temp(10); myclass A=temp;

若构造函数加上explicit 则编译不通过。

static 关键字修饰的静态成员和静态函数都是属于整个类的，而非静态成员和非静态函数是属于单个对象的。

即static 成员函数无法调用非静态成员函数，反之可以。

并且只有静态成员可以直接在类中初始化。

虚拟继承:

虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如下图所示。

类D继承自类B1、B2，而类B1、B2都继承自类A，因此出现如右图所示的局面（非虚基类）。这样基类A就被构造两次。

为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。最后形成如左图所示的情况。

实现的代码如下：

虚基类和非虚基类的区别

class A;

class B1:public virtual A;

class B2:public virtual A;

class D:public B1,public B2;

以下面的一个例子为例：

#include <iostream.h>

#include <memory.h>

class CA

{

int k; //如果基类没有数据成员，则在这里多重继承编译不会出现二义性

public:

void f() {cout << "CA::f" << endl;}

};

class CB : public CA

{

};

class CC : public CA

{

};

class CD : public CB, public CC

{

};

void main()

{

CD d;

d.f();

}

当编译上述代码时，我们会收到如下的错误提示：

error C2385: 'CD::f' is ambiguous

即编译器无法确定你在d.f()中要调用的函数f到底是哪一个。这里可能会让人觉得有些奇怪，命名只定义了一个CA::f，既然大家都派生自CA，那自然就是调用的CA::f，为什么还无法确定呢？

这是因为编译器在进行编译的时候，需要确定子类的函数定义，如CA::f是确定的，那么在编译CB、CC时还需要在编译器的语法树中生成CB::f，CC::f等标识，那么，在编译CD的时候，由于CB、CC都有一个函数f，此时，编译器将试图生成这两个CD::f标识，显然这时就要报错了。（当我们不使用CD::f的时候，以上标识都不会生成，所以，如果去掉d.f()一句，程序将顺利通过编译）

要解决这个问题，有两个方法：

1、重载函数f()：此时由于我们明确定义了CD::f，编译器检查到CD::f()调用时就无需再像上面一样去逐级生成CD::f标识了；

此时CD的元素结构如下：

|CB(CA)|

|CC(CA)|

故此时的sizeof(CD) = 8;（CB、CC各有一个元素k）

2、使用虚拟继承：虚拟继承又称作共享继承，这种共享其实也是编译期间实现的，当使用虚拟继承时，上面的程序将变成下面的形式：

#include <iostream.h>

#include <memory.h>

class CA

{

int k;