前言
以下问题以Q&A形式记录，基本上都是笔者在初学一轮后，掌握不牢或者频繁忘记的点
Q&A的形式有助于学习过程中时刻关注自己的输入与输出关系，也适合做查漏补缺和复盘。
本文对读者可以用作自查，答案在后面，需要时自行对照。
问题集
Q1：INT_MAX这个宏定义的具体数值是由什么决定的？
Q2：以下写法哪个有问题？
1）const int* a = &temp;
2）int const *a = &temp;
3）int* const p = &temp;
Q3：static关键字的作用
Q3.1：函数内static变量
Q3.2：类内static函数？如何理解：静态函数属于类而不是类的实例？
Q3.3：静态成员变量和静态函数，哪个只能在类外定义？
Q4：
1）new和malloc的区别？（返回&空间&语法元素&用法）
2）什么是自由存储区？
Q5：constexpr？怎么用？
Q6：volatile？
Q7：对于运算符"++"的重载，关于前置++与后置++的问题：
1）为什么后置++的函数需要返回对象，而不是引用？
2）为什么后置前面也要加const？
Q8：a++ 和 int a = b 在C++中是否是线程安全的？如何解决？
Q9：int (*ptr)(char); 和 int *ptr(char); 的区别？
Q10：什么是回调机制？如何实现？
Q11：关于cast强制转换的问题
Q11.1：解释：
double b = static_cast<double>(a);
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
int* b = const_cast<int*>(a);
Q11.2：这段代码中，p的动态转换为什么会抛出异常？
class Base {
public:int no;virtual void fun(){}
};class Person : public Base{
public:int age;
};int main(){Base b;Person p = dynamic_cast<Person &>(b); // 这里为什么抛出异常？Q13：动态强制转换 dynamic_cast是如何知道“enemy是一个Enemy对象”？C++的多态和C#的实现有何不同？
Q14：内存四区？
Q15：没有将基类的析构函数定义为虚函数，可能会导致什么问题？
Q16：如何防止内存泄露?
Q17：构造函数设为虚函数是有什么说法吗？
Q18： std::weak_ptr （弱引用智能指针）？
Q19：delete 释放的内存块的指针值会被设置为？
Q20：如何避免野指针
Q21：野指针和悬浮指针的区别
Q22：如何避免悬浮指针
Q23：分析运行下面的Test函数会有什么样的结果。
void GetMemory1(char* p)
{
p = (char*)malloc(100);
}
void Test1(void)
{
char* str = NULL;
GetMemory1(str);
strcpy(str, "hello world");
printf(str);
}
Q24：注意看这个free的位置，这段代码有什么问题？
void Test4(void)
{
char *str = (char*)malloc(100); strcpy(str, "hello");
free(str);
if(str != NULL) {
strcpy(str, "world");
cout << str << endl;
}
}
参考解答
Q1：INT_MAX这个宏定义的具体数值是由什么决定的？
A1：可以。头文件 <climits> 定义了符号常亮：例如：INT_MAX 表示 int 的最大值，INT_MIN 表示 int 的最小值。
INT_MAX 的值是由编译器和平台的整数大小决定的，而不是由 C++ 标准直接规定。
C++ 标准只规定了 int 类型必须至少有 16 位，但是大多数现代编译器都使用 32 位的 int 类型。
如果想知道你的系统上 INT_MAX 的具体值，可以简单地包含头文件并打印出来：
#include <iostream>
#include <climits>int main() {std::cout << "INT_MAX is " << INT_MAX << std::endl;return 0;
}Q2：以下写法哪个有问题？顶层指针和底层指针？
1）const int* a = &temp;
2）int const *a = &temp;
3）int* const p = &temp;
A2：哪个都没问题。对于1和2的合法性容易有记忆上的漏洞。
1和2都是底层const，指向的值不变。3是顶层指针，本身指向不变。
术语 "顶层" 和 "底层" 来源于const 关键字在声明中的相对位置。"顶层" 指的是指针变量本身的层面，而 "底层" 指的是指针所指向的数据的层面。这种命名方式有助于清晰地区分不同层面上的 const 限定，从而更好地理解指针的行为和限制。
本质上const类似于修饰，看修饰的是 *a 还是 p
Q3：static关键字的作用
Q3.1：函数内static变量
void exampleFunction() {
static int count = 0; //
count++;
cout << "Count: " << count << endl;
}
A3.1：静态变量：在函数内部使用 static 关键字修饰。
在程序的整个生命周期内存在，不会因为离开作用域而被销毁。
Q3.2：类内static函数？如何理解：静态函数属于类而不是类的实例？
class ExampleClass {
public:
static void staticFunction() {
cout << "Static function" << endl;
}
};
A3.2：和C#一样，静态函数属于类而不是类的实例，可以通过类名直接调用，而无需创建对象。
特点：不能调用非静态成员变量或者非静态函数。因为不能让非静态内容在它们生命周期开始前获知。
Q3.3：静态成员变量和静态函数，哪个只能在类外定义？
A：静态成员变量必须在类外部单独定义，以便为其分配存储空间。这是因为静态成员变量不属于类的任何特定实例，而是该类的所有实例共享的单一变量。由于静态成员变量与类的任何特定对象无关，它们在程序的全局命名空间中存在，因此需要在类外进行初始化。
class ExampleClass {
public:
static int staticVar; // 静态成员变量声明，合法
};
// 静态成员变量定义
int ExampleClass::staticVar = 0;
如果想在类内初始化，唯一的办法是加上const：
class ExampleClass {
public:
const static int staticVar; // 静态成员变量声明，合法
};
Q4：
1）new和malloc的区别？（返回&空间&语法元素&用法）
2）什么是自由存储区？
A4：
注意两个点：
1）new封装了malloc，只是添加了更多的内存维护
2）new在自由存储区上，实际上自由存储区也是堆的一部分，专门用来支持构造和析构的自动调用。
Q5：constexpr？怎么用？
A5：
const 表示“只读”的语义，constexpr 表示“常量”的语义
复杂系统中很难分辨一个初始值是不是常量表达式，可以将变量声明为constexpr类型，由编译器来验证变量的值是否是一个常量表达式。
必须使用常量初始化：
Q6：volatile？
A6：与该变量有关的运算，不要进行编译优化； // 不许抄近路
会从内存中重新装载内容，而不是直接从寄存器拷贝内容。 // 运行时变慢
使用场合：
在中断服务程序和CPU相关寄存器的定义
Q7：对于运算符"++"的重载，关于前置++与后置++的问题：
1）为什么后置++的函数需要返回对象，而不是引用？
2）为什么后置前面也要加const？
A7：
Q8：a++ 和 int a = b 在C++中是否是线程安全的？如何解决？
A8：都不是，编译器视角下都不是原子的。
C++11新标准提供了对整形变量原⼦操作的相关库，即std::atomic
std::atomic 是个模板类，具体用法：
std::atomic<int> value;
value = 99;
这里有个坑：
std::atomic<int> value = 99; 这个语法不能在g++上通过，因为禁止拷贝构造自动生成
Q9：int (*ptr)(char); 和 int *ptr(char); 的区别？
A9：
1）int (*ptr)(char); 是在声明一个指向函数的指针。这个指针可以指向一个接受 char 类型参数并返回 int 类型的函数。
2）而 int *ptr(char); 则不是声明一个函数指针，而是声明了一个函数。其修正格式应该是：int* ptr(char)
这个函数接受一个 char 类型的参数，并返回一个指向 int 的指针。
关于函数指针的示例代码：
int main(){int (*ptr)(char);ptr = &show;cout << ptr('y') << (*ptr)('y') << endl; // ptr('y') // (*ptr)('y')// 这两种调用方式在功能上是等价的，都能达到调用函数指针指向的函数的目的。然而，使用 // ptr('y') 的方式更为简洁，通常在C++中更常见。Q10：什么是回调机制？如何实现？
A10：回调机制是一种编程模式，允许将一个函数作为参数传递给另一个函数，然后在需要的时候从内部灵活调用。
所以用上面讲的函数指针方法就可以实现。我们使用的 sort 算法就属于回调的一种应用。
除此之外，界面的用户操作处理也会用到
Q11.1：解释以下cast强制转换变量的作用：
double b = static_cast<double>(a);
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
int* b = const_cast<int*>(a);
A11：
强制转换
C风格的方法： int a = (int)c
C++风格的方法：
1）静态转换：用于非多态类型的转换，如基本数据类型，编译时而非运行时进行检查
int a = 10;
double b = static_cast<double>(a); // 将int转换为double
2）动态转换：用于处理多态性，只能在含有虚函数的类层次结构中使用
class Base { virtual void dummy() {} };
class Derived : public Base {};
Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);// 父转子
if (derivedPtr) {
// 转换成功
}
3）const_cast：用来越界修改const值，emmmm...
使得不能改写的const类型数据变得可以修改：
const int* a = new int(10);
int* b = const_cast<int*>(a); // 移除const限定符
Q11.2：这段代码中，p的动态转换为什么会抛出异常？
class Base {
public:int no;virtual void fun(){}
};class Person : public Base{
public:int age;
};int main(){Base bPerson p = dynamic_cast<Person &>(b); // 这里为什么抛出异常？A11.2：
类型不匹配：b 是 Base 类型的对象，而 Person 是从 Base 派生的类。dynamic_cast 用于类层次结构中的向下转型，即从基类向派生类转换。然而，这里的 b 实际上并不是 Person 类型的对象，而仅仅是 Base 类型的对象。
dynamic_cast 要求：dynamic_cast 需要对象实际上是目标类型的实例或者派生自目标类型。由于 b 不是 Person 或其派生类的实例，dynamic_cast 无法安全地进行转换。
Q12：对于动态强制转换，如何应用？
A12：安全的向下转型：主要用来“将Entity对象转化为Player或者Enemy对象”
我们假设基类Entity有两个子类：Player和Enemy，
通常情况下，Player或者Enemy转化成Entity比较简单，因为他们本来就是，只需要隐式转换即可、
但是“Entity转化为Player或者Enemy”，就必须要cast方法进行强制转化。
工程中，使用的指针可能是个什么样的对象未必清楚，因此这个功能主要用来做验证，
比如尝试进行转换 player→entity 是合法的，而 player→enemy 就会返回nullptr；
如果不这样做而是用 强制转换的方法（如 ：player = (Player *)enemy ），语法上能通过，但是访问虚空成员就容易产生崩溃。
所以，工程上一定是用dynamic_cast的安全方法来进行对象的转换和验证
int main() {
Animal* aa = new Bird; // 注意这里创建的是Bird对象，但类型是Animal*
aa->func(); // 多态性：调用Bird的func
Bird* bb = dynamic_cast<Bird*>(aa); // 动态转换
if (bb) {
bb->func(); // 调用Bird的func
} else {
std::cout << "dynamic_cast failed" << std::endl;
}
delete aa;
return 0;
}
Q13：动态强制转换dynamic_cast是如何知道“enemy是一个Enemy对象”？C++的多态和C#的实现有何不同？
A13：dynamic_cast主要是通过RTTI（运行时类型识别）进行识别的，这种方式会使程序产生一定的开销。
在C++中，多态性主要通过虚函数和基类指针或引用来实现，而装箱和拆箱通常与C#等语言中的值类型和引用类型有关。
C++多态性是通过虚函数和运行时类型识别（RTTI）实现的，而C#装箱和拆箱是通过语言的类型系统和垃圾回收机制实现的。
Q14：内存四区？
A14：堆栈全常，还有个代码区
Q15：没有将基类的析构函数定义为虚函数，可能会导致什么问题？
A15：内存泄漏！
基类指针 p_entity 指向子类对象 player时，如果 Entity类的析构不是virtual的
那么这种情况下释放 p_entity 时不会调用子类析构函数，子类没正常释放资源，就会产生内存泄漏
Q16：如何防止内存泄露?
A16：将内存的分配封装在类中，构造函数分配内存，析构函数释放内存；使用智能指针
Q17：构造函数设为虚函数是有什么说法吗？
A17：没有意义。构造函数不应该被定义为虚函数
Q18： std::weak_ptr （弱引用智能指针）？
A18：std::weak_ptr 可以从 std::shared_ptr 创建，但不会增加引用计数，不会影响资源的释放。
通过 std::weak_ptr::lock() 可以获取⼀个 std::shared_ptr 来访问资源。
#include <memory>
std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
std::weak_ptr<int> weakPtr = sharedPtr;
Q19：delete 释放的内存块的指针值会被设置为？
A19：delete 释放的内存块的指针值会被设置为 nullptr ，以避免野指针。
free 不会修改指针的值，可能导致野指针问题。
Q20：如何避免野指针
A20：
1）在释放内存后将指针置为 nullptr
int* ptr = new int;
// 使⽤ ptr 操作内存
delete ptr;
ptr = nullptr; // 避免成为野指针
2）使用函数返回指针变量时，避免返回局部变量的指针；
3）使用智能指针：避免显式 delete，指针会在超出作⽤域时⾃动释放
Q21：野指针和悬浮指针的区别
A21：野指针一般涉及指针问题。危害：可能导致访问已释放或无效内存，引发崩溃或数据损坏。
悬浮指针一般是引用问题，即指向已被delete或free销毁对象的引用。危害：可能导致访问销毁对象的未定义行为
Q22：如何避免悬浮指针
A22：悬浮指针指向的内存可能已经被释放或重新分配，导致未定义行为和程序错误。其避免方法有：
使用智能指针：如 std::unique_ptr、std::shared_ptr 和 std::weak_ptr，自动管理内存，减少手动管理内存的需要。
std::unique_ptr<int> ptr(new int); // 使用unique_ptr管理内存避免跨函数返回局部指针：不要从函数返回局部变量的指针，因为局部变量在函数返回后生命周期结束。
int* getPointer() {int localValue = 42;return &localValue; // 错误：返回了局部变量的地址}Q23：分析运行下面的Test函数会有什么样的结果。
void GetMemory1(char* p)
{
p = (char*)malloc(100);
}
void Test1(void)
{
char* str = NULL;
GetMemory1(str);
strcpy(str, "hello world");
printf(str);
}
A23：运行 Test1 函数的结果很可能是程序崩溃，因为 strcpy 试图向一个空指针写入数据。
为什么说GetMemory1并不能传递动态内存？
void GetMemory1(char* p)
{
p = (char*)malloc(100);
}
在C语言中，函数参数传递是通过值传递来实现的，也就是说，当一个变量作为参数传递给函数时，实际上是传递了这个变量的一个副本。在你提供的GetMemory1函数中，参数p是一个char*类型的指针，它指向一个字符。
当你在函数内部使用malloc来分配内存并尝试将p指向这块新分配的内存时：
p = (char*)malloc(100);
这里，p指针的副本被修改了，它现在指向了新分配的内存区域。但是，这个修改只发生在函数内部，原始的指针（即传递给函数的那个副本）并没有被改变。因此，当函数执行完毕后，返回到调用函数时，原始的指针仍然指向它原来的位置，而不是新分配的内存区域。
这就是为什么说GetMemory1不能传递动态内存的原因。要正确地传递动态内存，你需要使用指针的指针或者引用的引用，这样修改内部的指针就可以反映到外部的指针上。例如：
void GetMemory2(char** p)
{
*p = (char*)malloc(100);
}
Q24：注意看这个free的位置，这段代码有什么问题？
void Test4(void)
{
char *str = (char*)malloc(100); strcpy(str, "hello");
free(str);
if(str != NULL) {
strcpy(str, "world");
cout << str << endl;
}
}
A24：篡改动态内存区的内容，后果难以预料。非常危险。
因为 free(str)；之后，str成为野指针，if（str != NULL)语句不起作用。