C++总结体会

摘要：本文主要记录了在复习c++过程中的体会。

1、关于const

1. 在c++中，const代表的是一种只读权限，即代表变量的值不可以再修改；
2. 相比define而言，const修饰的数据可以有类型，更加地注重作用域；
3. const修饰的变量用基础数据类型进行初始化时，只会标记到符号表，而不会分配内存；用变量名来进行初始化时，会分配内存；当const修饰的变量是一个自定义的数据类型时，那么也会分配内存；
4. 只要进行了内存的分配，那么就可以通过指针的方式进行修改；
5. 在c语言中const修饰的变量默认跨文件；而c++中的const修饰的变量默认作用于本文件，如果要实现跨文件，那么就应该借助extern；

2、关于typedef

1. typedef可以用于给数据类型起别名：typedef  int  size，那么就可以用size来定义int型数据；
2. typedef可以用于给某一个数组类型起别名：typedef  int   Arry[10]，那么就可以用Arry来直接定义一个元素个数为10的int型的数组：Arry  buff={.......}；
3. typedef可以给一个指针类型起别名：typedef  int *  ptr，那么就可以直接用ptr来定义一个指针：ptr  p相当于int *  p；

3、关于引用reference

1. 变量本质上就是某一个内存空间的代号，而引用本质上就是这个内存空间的代号2、代号3.......，所有的代号在本质上都一样，完全等价；
2. 在定义一个变量时可以不对其进行初始化：int a；但是定义一个引用时则必须进行初始化：int  &b=a；这是因为既然起别名就要知道是为谁起别名，否则就没有意义，而被起别名的这段空间也必须是明确的才可以，正如我们给一个人起外号，必须要知道这个人是谁，我们不能说给某人起外号，给一个不知道的人起外号这都是没有意义的，所以引用不可以用于NULL；
3. 对一个单一的变量建立引用是及其简单的，而给一个数组建立引用可以采用两种方式：第一种是借助typedef（typedef  int   Arry[10]；Array &buff=arr；这里的arr是一个数组名）；第二种是要将&buff括起来，表示数组名的引用（int （&buff）[10]=arr）；
4. 引用是通过指针常量来实现的（type  * const  ref=&val）；这里的const是说明ref这个指针只可以指向val的空间，而不能指向其他的地址，这也就是为一个别名不能用于多个变量的实现原理；
5. 对于指针的引用，在设置形参时，我们可以用二级指针的形式来表示  **p  ，也可以直接用引用来表示  *&p；
6. 常量引用const  type &b=a；这里运用const的意思是不希望通过引用的方式将变量的值改变，多数应用在传参的过程中，不希望操作形参时将实参改变了；

关于指针的引用，这里加入一段代码，帮助理解：

#include<iostream>

using namespace std;

struct Teacher
{
    int age;
};

void AgeChange(Teacher **teacher) { //这里的形参采用的是二级指针的方式
    *teacher = new Teacher;    
    (*teacher)->age = 10;
}
void Age_Change(Teacher *&teacher) {   //这里的形参就是一个引用
    teacher->age = 100;
}

int main() {
    Teacher *MrLiu=NULL;    //定义一个指针变量
    
    AgeChange(&MrLiu);   //根据形参要求，这里传入的是指针的地址
    cout << (*MrLiu).age << endl;

    Age_Change(MrLiu);
    cout << (*MrLiu).age << endl;

    delete MrLiu;
    
    system("pause");
    return 0;
}

4、关于extern"C"

在c++编译环境中，程序编译后，会发生函数的重载。而在c语言中并不会发生函数的重载，也就是说，当我们在c++环境中去调用c语言模块下的函数时，由于c++连接器会寻找重载后的函数，这当然是找不到的，那么此时就需要用到extern"C"。具体实现如下：

MyModule.h

#ifndef MYMODULE_H
#define MYMODULE_H

#include<stdio.h>

#if __cplusplus
extern "C"{
#endif

    void func1();
    int func2(int a,int b);

#if __cplusplus
}
#endif

#endif

MyModule.c

#include"MyModule.h"

void func1(){
    printf("hello world!");
}
int func2(int a, int b){
    return a + b;
}

TestExternC.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

#if 0

    #ifdef __cplusplus
    extern "C" {
        #if 0
            void func1();
            int func2(int a, int b);
        #else
            #include"MyModule.h"
        #endif
    }

    #endif

#else

    extern "C" void func1();
    extern "C" int func2(int a, int b);

#endif

int main(){
    func1();
    cout << func2(10, 20) << endl;
    return EXIT_SUCCESS;
}

5、关于class和struct

struct就是一个public权限下的class。

6、关于拷贝构造函数

有三种情况会调用拷贝构造函数：

1. 用旧对象初始化新对象；
2. 函数的形参是普通的对象，进行值传递会调用拷贝构造函数；
3. 函数的返回值是一个普通的对象；

7、关于构造函数的调用

1. 如果在一个类中，用户不写任何一个构造函数，那么系统默认会提供无参构造函数、析构函数、拷贝构造函数；
2. 如果在一个类中，用户写了拷贝构造函数，那么系统就不再提供任何一种构造函数；
3. 如果在一个类中，用户写了非拷贝构造的构造函数，那么系统不会再提供无参构造函数，但是依然会提供默认构造函数；

8、关于深拷贝和浅拷贝

我们知道，直接将一个对象赋值给另一个对象，这样的拷贝就是浅拷贝。如果被拷贝的对象里面只有基本的数据类型，那么这样的拷贝无非就是数据的相互赋值，完全没有问题。但是如果类中含有指针变量，指针变量在定义的时候是需要指向一段地址的，也就是说需要从堆中拿出一块内存，那么在这个指针进行拷贝的时候，会把这个指向的内存空间也进行拷贝；在堆中获取了空间以后，是需要释放的，那么在两个对象都被释放的时候，同一段内存就被释放了两次。这样就是违法的，会导致程序执行的崩溃，这也就是浅拷贝的弊端所在。

下面的例子就是浅拷贝：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

class Person {
public:
    Person() {
    }
    Person(const char *name) {
        m_name =(char*)malloc(strlen(name)+1);
        strcpy(m_name,name);
    }
    ~Person() {
        if (m_name!=NULL)
        {
            cout << "析构函数调用" << endl;
            free(m_name);
        }
    }
private:
    char *m_name;
};
void test() {
    Person p1("abc");
    Person p2(p1);    //系统自带的默认拷贝构造函数，直接崩溃，属于浅拷贝
}

int main() {
    test();

    system("pause");
    return 0;
}

而所谓深拷贝，就是要避免浅拷贝存在的弊端，为新的对象创建新的空间，然后再进行拷贝，这样就不会导致同一段内存被释放两次。具体如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

class Person {
public:
    Person() {
    }
    Person(const char *name) {
        m_name =(char*)malloc(strlen(name)+1);
        strcpy(m_name,name);
    }
    Person(const Person &person) {   //自定义的拷贝构造函数
        m_name = (char*)malloc(strlen(person.m_name)+1);
        strcpy(m_name,person.m_name);
    }
    ~Person() {
        if (m_name!=NULL)
        {
            cout << "析构函数调用" << endl;
            free(m_name);
        }
    }
private:
    char *m_name;
};
void test() {
    Person p1("abc");
    Person p2(p1);    //拷贝构造函数
}

int main() {
    test();

    system("pause");
    return 0;
}

9、关于explicit

explicit主要是防止隐式转换。