c++ 基础知识整理1

bool    //1 byte  = 8 bits
char    //1 byte
short   // 2 byte
int   //4 byte = 32 bits ,一个位置存储符号，所以 -2^31 ~ 2^31
unsigned int    //4 byte, 0~2^32
float   //4 byte
double  //8 byte

 char* // 8 byte  
 int* // 8 bytes
 float* //8 byte
 double* //8 byte

1. 虚函数：

基类会生成虚函数表，运行时会产生额外的损耗：

1. 需要额外的内存存储 V表，以确保可以在运行时分配到正确的函数；基类中存在一个成员指针，指向V表
2. 虚函数调用的时候，需要遍历V 表，确定映射到的具体的函数

2. 纯虚函数

虚函数，可以不重写（override） – optional
纯虚函数：必须重写（override） – 不提供默认值
virtual fuc() = 0;
c++中 纯虚函数 和其他语言（Java/c##）中的接口类似，但是并不需要 interface 关键字；

3. 数组

    int example[5]; 
    int* ptr = example;
    example[2] = 5;
    *(ptr + 2) = 6; // 等价于 example[2] = 6; 指针的偏移
    *(int *)((char*)ptr + 8) = 7;// 和上述等价；+偏移量 与指针大小有关； 1 int = 4 char
    

    //生命周期不同， 需要考虑 分配的内存何时被回收
    int example[5]; // stack  栈分配
    int* anthor = new int[5];//heap 堆内存 需要 delete，否则内存不会释放
    delete[] anthor;// 数组内存释放 需要delete[];

    // 计算数组大小的方式不同
    //对于 栈上的内存--可计算
    int count = sizeof(example) / sizeof(int) ;//= 5*4/4 = 5;
  
    cout << sizeof(anthor) <<endl; // 8
	cout << sizeof(int) <<endl; // 4
	cout << sizeof(int*) <<endl; // 8
    // 对于堆上的内存，不可计算
    // 推荐使用std::array 

4. 函数指针

//1. 函数指针的定义
 void(*func)();

 //2. 通常使用 typedef 看起来更好看
 typedef void(*funcName)(int);//将带有int参数的函数定义为funcname

 void acca(int a) {
    cout<< ""<<endl;
 }

funcName fa = acca;
fa(1);//等价于  acca(1);

//3. 作为函数形参

void forEach (vector<int>& arra, funcName) {
    //等价于  void forEach (vector<int>& arra, void(*funcName)(int)) {
    for(int va : arra) {
        funcName(va);
    }
}

//调用方式
forEach(arra, acca); //第二个参数直接传递需要调用的函数

//4. 更高级的调用，使用lambda ，lambda为匿名函数，可以代替acca这个需要声明的函数，作为简单的函数，直接写在函数参数中；
void acca(int a) {
    cout<< ""<<endl;
 }
forEach(arra,acca);
//等价于
forEach(arra,[](int a){ cout<< ""<<endl;});

//通常会换行，写作：
forEach(arra,[](int a) {
    cout<< ""<<endl;
});

5.lambda

[] //捕获 nothing
[a] //捕获一个参数
[=] //以值传递 的方式捕获所有参数，copy 方式
[&] //以引用的方式 捕获所有参数

void forEach (vector<int>& arra, void(*funcName)(int)) {}
// lambda 使用std::fuction 进行传递 ，裸函数指针 对于捕获会有问题
void forEach (vector<int>& arra, std::fuction<void(int)>& func) {}

//使用值传递（copy）方式捕获的变量，在lambda函数内部不可以被再次赋值，如果要进行赋值操作，需要加 mutable 修饰符；
int a = 10;
auto lambda = [](int) {cout<<"";};
auto lambda = [a](int) {cout<<a;};
auto lambda = [=](int) {cout<<a;};
auto lambda = [=](int) mutable {a = 9; cout<<a;};

6.二维数组/多维数组

    // 1. 二维数组 初始化
    int** a2b = new int*[5];
    for (int i = 0; i < 5; i++) {
        a2b[i] = new int [3];
    }
    // 上述创建了一个 5行3列的数组
    //2. 数组赋值
    for(int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            a2b[i][j] = i+j;
			cout<< a2b[i][j]<< " ";
        }
		cout<<endl;
    }
    //二维数组：
    //  0 1 2 
	//  1 2 3 
	//  2 3 4 
	//  3 4 5 
	//  4 5 6 
    //3. 数组 内存管理- 内存释放
    for (int i = 0; i < 5; i++) {
       delete[] a2b[i];
    }
    delete[] a2b;

    //4. 基于内存分配的碎片化/不连续，使用二维数组/多维数组 存在cache miss ，导致性能损伤，建议使用一维数组 进行内存优化
    //使用一维数组 实现二维数组的能力：
    int x = 5;
    int y = 3;
    int* a1b = new int[x*y];
    for(int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            a1b[i+j*y] = i+j;
			cout<< a1b[i+j*y]<< " ";
        }
		cout<<endl;
    }

    //内存释放
    delete[] a1b;