c++ 知识点笔记（2023.12.12）

c++ 知识点笔记(2023.12.12)

6.讲一讲int* p[n] 和 int(* p)[n] 以及int* p()和int（* p）()的区别

tips:牢记”[]”的优先级比较高，所以要用优先级更高的"()"做区分

int *p[n] ：由于“[]”的优先级比较高，所以先看p[],说明p是一个数组，再看剩下的部分得知，p这个数组里面的元素类型为int型指针。

int（*p）[n] : 由于“()”的优先级比较高，所以先看 * p ，说明p是一个指针，再看剩下的部分，得知p指针指向的是 一个长度为n的一维数组。

int* p( ) : 表示p为函数，范围值为int*

int (*p)() 表示p为函数指针，函数原型int func()

7.volatile关键字有什么用？

C++中的volatile和const对应。表示变量可以被编译器未知的因素所更改，比如操作系统、硬件或者其它线程。遇到volatile，编译器就不再进行优化，从而提供对特殊地址的稳定访问。

8.C++的智能指针用过吗？怎么样？

C++的智能指针均位于库里，有四种：shared_ptr/unque_ptr/weak_ptr/auto_ptr

shared——ptr

共享指针，（指向同一块内存）只有最后一个共享指针被释放，资源会自动销毁。（tips：当有裸指针混用时，只要共享指针都被释放，内存就会被销毁，裸指针就会悬空）

原理：无非是利用一个计数器，当发生使用赋值拷贝构造函数，运算符重载，作为函数返回值，或者作为一个参数传递给另一个参数，计数+1，当shared_ptr赋新值或者销毁，计数-1，直到计数为0，调用析构函数释放对象。

缺点是存在循环引用问题，见9；

std::shared_ptr<int> sptr = std::make_shared<int>(...); //初始化方法一 效率更高
std::shared_ptr<int> sptr(new int(...)); //初始化方法二

sptr.reset(); //指针释放
sptr.rest(new int) //原共享指针组-1，指向新内存

unique_ptr

独占式的指针，离开unique_ptr对象的作用域时，会自动释放资源。

由于指针或引用在离开作用域是不会调用析构函数的，但对象在离开作用域会调用析构函数。unique_ptr本质是一个类，将复制析构函数和赋值析构函数声明为delete

std::unique_ptr<int> uptr = std::make_unique<int>(...);//初始化方法一 效率更高
std::unique_ptr<int> uptr(new int(...));//初始化方法二

uptr.release();//接触uptr与资源的绑定，并返回一个指向资源的裸指针
delete uptr;
uptr = nullptr;

unique_ptr<int> uptr1 = make_unique<int>(100);
unique_ptr<int> uptr2(uptr1.release()); //接触资源与uptr1的绑定，并直接与uptr2绑定

weak_ptr

与shared_ptr一起使用，作为资源的观察者，不影响对象的引用计数。

auto_ptr

已被弃用

9.什么是shared_ptr 的循环引用问题，如何解决？

struct box
{
    int data;
    shared_ptr<box> ptr;
    box(int data):_data(data){};
    ~box(){cout<<"~box()"<<endl;}
};

int main()
{
    shared_ptr<box> boxA = make_shared<box>(1);
    shared_ptr<box> boxB = make_shared<box>(2);
    
    cout << boxA.use_count() << endl;//1
    cout << boxA.use_count() << endl;//1
    
    boxA->ptr = boxB;
    boxB->ptr = boxA;
   
    cout << boxA.use_count() << endl;//2
    cout << boxA.use_count() << endl;//2
           
    return 0;
}

最一般的情况是，对象A内有一个shared_ptr指向对象B，对象B内也有一个shared_ptr指向A，另外，又有两个单独的shared_ptr分别指向A/B;

A与B分别有两个shared_ptr指向他们，所以他们引用计数均为2，造成了循环引用，谁也不会被释放，因为始终有另外一个指针指向它。

解决方法：1.当剩下最后一个引用时，需要收到打破循环引用释放对象；

​ 2.当A的生存周期超过B的生存周期，B改为一个普通指针指向A；

​ 3.将共享指针改为弱指针weak_ptr;

一般采用第三种方法，原理是弱指针的指针不会增加shared 引用数量。

struct box{   
    int data;   
    weak_ptr<box> ptr;   
    box(int data):_data(data){};  
    ~box(){cout<<"~box()"<<endl;}
};
    int main(){    
        shared_ptr<box> boxA = make_shared<box>(1); 
        shared_ptr<box> boxB = make_shared<box>(2);  
        cout << boxA.use_count() << endl;//1 
        cout << boxA.use_count() << endl;//1    
        boxA->ptr = boxB; 
        boxB->ptr = boxA;   
        cout << boxA.use_count() << endl;//1  
        cout << boxA.use_count() << endl;//1   
        return 0;
    }

10.unique指针如何在函数作为参数传递/unique指针在函数间的使用方法？

改变unique所指的资源

首先unique指针是独占的，不能赋值（unique_ptr不是不能赋值，而是不能赋左值，可以赋右值），直接作为函数参数传递显然是不行的。

以下是错误用法

void pass_up(unique_ptr<int> up) //错误用法
{
    cout<<"In pass_up"<<*up<<endl;
}

int main()
{
    auto up = make_unique<int>(123);
    pass_up(up);           //错误用法
}

其实，我们不需要传递unique_ptr本身，我们只需要传递unique_ptr所指向的资源。

方法一

void pass_up(int& value) //参数是 int 的引用
{
    cout<<"In pass_up"<<*up<<endl;
}

int main()
{
    auto up = make_unique<int>(123);
    pass_up(*up);           
}

方法二

void pass_up(int* p)  
{
    cout<<"In pass_up"<<*up<<endl;
}

int main()
{
    auto up = make_unique<int>(123);
    pass_up(up.get());       //up.get() 返回的是资源的裸指针
}

改变unique本身

void pass_up(unique_ptr<int> up)  
{
    cout<<"In pass_up"<<*up<<endl;
}

int main()
{
    auto up = make_unique<int>(123);
    pass_up(move(up));//move()函数作用是release()类似，解除up与资源的绑定，可以转移给另外一个unique_ptr
    if(up == nullptr) cout<<"up is moved."<<endl;//up指针不再指向原资源，变成空指针了
}

unique可以作为函数返回值

unique_ptr return_uptr(int value)  
{
   	unique_ptr<int> up = make_unique<int>(value);
    return up;
}

int main()
{
    unique_ptr<int> up = return_uptr(321);//unique_ptr不是不能赋值，而是不能赋左值，可以赋右值 而return的东西已经是右值了
    cout<<"up:"<<*up<<endl;
}

11.数组与指针的区别？指针数组和数组指针？

数组存放一组元素，而指针指向某一个对象。从底层实现上看，数组也是由base指针和各维度长度等组成，数组元素曾放在连续地址上。

指针数组是保存指针的数组，比如int* a[10],而数组指针是指向数组的指针，比如：

int var[10];
int *ptr = var;
int *ptr = &var[10];//与上面等价

在C++中，数组名代表数组中第一个元素（即序号为0的元素）的地址。如果是二维数组，则可以通过* (* (arr+i)+j)来访问arr[i] [j]

12.你知道函数指针吗？讲一讲

函数指针是指向函数的指针，是早期c的项目中经常能看到。

作用1：通过函数指针调用函数

int foo(){return -1;}

int (*ptrfoo)() = foo;//不要写成foo()
ptrfoo();//使用方式1
(*ptrfoo)();//使用方式2

作用2：回调函数（以函数指针为参数的函数）

int Max(int a, int b){
    return a>b?a:b;
}
int Min(int a, int b){
    return a<b?a:b;
}

void printData(int (*p)(int,int),int a,int b)  //充当回调函数
{
    cout<<p(a,b)<<endl;
}

int main()
{
    void (*pp)(int (*)(int,int),int,int) = printData; //指向printData的函数指针
    pp(Max,1,2);
    pp(Min,1,2);
}

13.什么是注册函数？什么是回调函数？

回调函数无非是对函数指针的应用，用函数指针来调用一个函数，而注册函数则是将函数指针作为参数传进去，便于其他函数调用。

14.C++从源文件到可执行文件需要经历哪些步骤？

预处理阶段(preprocessing)-》编译阶段(compilation)-》汇编阶段(assembly)-》链接阶段(linking)

预处理阶段：编译器对文件包含关系进行检查（头文件和宏），将其做相应替换，生成.i文件；

**编译阶段：**将预处理的生成文件转化为汇编文件.s;

**汇编阶段：**将汇编文件转化为二进制机器码，对应后缀是.o(Linux),.obj(Windows);

**链接阶段：**将多个目标文件及所需要的库连接成可执行文件.out(Linux) .exe(Windows);