c/c++复习 2.0 ProMax

main函数执行前后做了什么

1. 初始化.data数据段，包括静态变量和全局变量
2. 初始化.bss字段，包括int 0; bool false； 指针 NULL
3. 设置栈指针、main函数的参数传递、全局对象的构造函数 _attribute__((constructor))自行注册
4. main之后：全局对象的析构函数 atexit或__attribute__((destructor))自行注册

指针和引用传参

1. 局部变量时要用指针传值，因为局部变量超出作用域就会被销毁，引用会指向无效
2. 比如递归这种栈空间敏感的操作，尽量用引用，开销小一点
3. 传递一个类对象，引用，如果直接传值会拷贝一份，很占空间，为什么不用指针呢，C++标准吧...

栈和堆

1. 栈很小，大小固定由操作系统管理，只有几M，堆一般是几G，new/delete管理，
2. 栈从顶到底，申请的地址递减，可以通过ulimit -a查看，堆递增，会有碎片，也更慢点
3. 栈可以动态(alloc)静态申请，堆只能动态。

new/delete 和 malloc/free

1. new封装的malloc，可以直接用free释放，但是不会析构
2. new自动计算要分配多少，malloc手动所以不安全
3. new相当于一个运算符，malloc相当于一个库函数，需要include<stdlib.h>
4. new/delete返回具体指针，malloc/free返回void* 要自己转
5. free之后并不是直接删除，而是缓存到ptmalloc回收起来，说不定等会还有用
6. malloc底层，分配小于128k用brk() 大于128k用mmap() 内存池管理

sizeof和strlen

1. sizeof是运算符，编译时就得到结果，strlen是库函数，运行时得到结果
2. sizeof可以对任何参数，strlen只能对字符指针且末尾是\0

常量指针和指针常量

1. int *const p 不能改变指向
2. int const /* p 指向了一个常量

结构体和类

1. class默认成员私有、私有继承；struct都是public
2. c语言的struct没有权限设置，而且不能有函数

数组名和指针

1. 数组名可以理解为常指针
2. 把数组名作为参数传递后，数组名就退化为指针了，可以用++ -- 等操作符了！！但sizeof得不到数组原大小了

final和override

1. override重写虚函数
   
   

2. final标志不可以被继承/重写虚函数且不可以被重写
   
   

拷贝初始化和直接初始化

1. 直接初始化：string s("123")
2. 拷贝初始化：string s = "123" string s1 = s string s1(s)

野指针和悬空指针

1. 野指针指的是没有初始化，悬空指针最开始指的值已经被释放
2. 为了避免野指针，写了就立即赋值，为了避免悬空指针，释放了就立即设为NULL

深浅拷贝

1. 浅拷贝指的是把一个对象复制给另一个对象，如果对象里有指针类型的值也是把指针复制过去，所以相当于和原来的对象共享一块内存
2. 深拷贝也是复制对象，但是遇到指针类型会把指针指向的值也复制到另一个地方，并且修改指针指向，所以原来对象的值改了不会影响！！

异常处理

try catch throw关键字

try{
    if(xxx) throw 1
    if(yyy) throw "err"
    if(zzz) throw Stu()  //Stu是个类，加括号表示默认构造函数，创建一个临时对象
}
catch(int i){
    //处理xxx的异常
}
catch(const char* j){
    //处理yyy的异常
}
catch(const Stu &s){
    //处理zzz的异常
}

• catch匹配不到会报错，可以用catch(...)匹配所有异常，但不推荐，因为所有异常统一处理会有问题！！

//定义函数时抛出异常，意思是fun()函数可能存在下列异常，具体有没有异常取决于内部实现！！！好处就是不用try了
int fun() throw(int,double,A,B,C){...};

• 还有一种就是c++自带的exception类及其衍生，在std::下，直接用就行
  
  

void myFunction(int x) {
    if (x < 0) {
        throw std::runtime_error("Something went wrong!");
    }
}

三种用于debug的new

1. 普通的new:分配失败后抛出异常bad_alloc，而不是返回NULL

try
{
    char *p = new char[10e11];
    delete p;
}
// 这里的err是一个bad_alloc类型的对象的引用！！
catch (const std::bad_alloc &err)
{
    cout << err.what() << endl;
}

1. nothrow new: 分配失败返回NULL，不抛出异常

char *p = new(nothrow) char[10e11];
if (p == NULL)
{
    cout << "alloc failed" << endl;
}
delete p;

1. placement new:在一块分配好的足够用的内存上new，实际上只是调用了构造函数，不会分配新内存，所以不要delete q！！

char *p = new(nothrow) char[sizeof Stu + 1];
if (p == NULL) {
    cout << "alloc failed" << endl;
}
Stu *q = new(p) Stu;  //placement new:不必担心失败，只要p所指对象的的空间足够ADT创建即可
//delete q;//错误!不能在此处调用delete q;
q->Stu::~Stu();//显示调用析构函数
delete[] p;

静态变量何时被初始化？

1. 基本数据类型+常量初值+全局 = 编译时初始化
   
   staic int i = 1
2. 不是基本数据类型(类对象)/不是常量 = 加载时初始化(也是main之前)
   
   static Stu s

static int *p = new int[1024]
3. 局部静态变量 = 首次使用时初始化

类成员的列表初始化和函数体内初始化？

class MyClass {
public:
    //列表初始化
    MyClass(int a, int b):num1(a),num2(b){}
    //函数体内初始化
    MyClass(int a, int b) {
        num1 = a;
        num2 = b;
    }
private:
    int num1;
    int num2;
};

1. 列表初始化更高效，因为在函数体执行前就分配好空间，赋值完毕了
2. 列表初始化不涉及赋值，赋值一般会产生临时对象，浪费空间
3. 对于const/引用成员，必须列表初始化，因为需要在创建对象时初始化，且不能再修改，没默认构造也要列表初始化

string与char[]

• string实际上封装的char*
• string可以动态扩展，每次扩展申请一块原来的二倍空间，比如本来是5，申请后就是10，申请后拷贝到新的空间！

组合和继承

1. 组合指的是类对象作为另一个类的成员
2. 继承的缺点是子类可以看到父类细节、继承后无法修改、子类父类高耦合
3. 组合的优点是低耦合、外层对象不可见内层细节、缺点是产生过多对象，容易弄混

函数调用中栈的作用

1. 返回地址先入栈，参数从右向左入栈、执行中可能会入栈一些临时变量、局部变量
2. 执行完毕后，返回值存在寄存器而非入栈，返回地址弹出栈

隐式转换

1. 常见的int char long(从小向大转) 还有子类转父类，都是隐式转换.
2. 构造函数前加上exclipit防止隐式转换

class String {
public:
    explicit String(const char* str) {
        // 构造函数的实现
    }
};

void func(String s) {
    // 函数的实现
}

int main() {
    const char* str = "Hello";
    // 编译错误，无法进行隐式类型转换
    func(str);
    return 0;
}

strcpy、memcpy、sprintf

1. strcpy用于复制字符串, 不用指定长度,遇到\0结束
   
   char* strcpy(char* destination, const char* source);
2. memcpy将一块字节复制到另一块，不关心内容，需指定长度
   
   void* memcpy(void* destination, const void* source, size_t num);
3. sprintf用于把源格式化为一个字符串
4. 执行效率memcpy>strcpy>sprintf

阻止类被实例化、阻止自动生成拷贝构造

1. 把构造函数设为private、构造函数=delete都可以阻止类被实例化
2. 自己定义一个拷贝构造函数、=delete都可以阻止自动生成拷贝构造

this

1. 静态成员没有this
2. this指向对象的首地址，用途主要是：返回对象本身(return *this) 形参成员重名赋值(this->x = x)
3. this在成员函数开始前构造，函数结束后释放

内联函数

1. 用于较小的，不包含循环等控制语句的函数
2. 在调用处展开，空间换时间！
3. 最好定义在头文件而不只是声明