C++简单编译
auto关键字
auto关键字用于自动类型推导。它允许编译器自动推断变量的类型，使得代码更加简洁和易于编写，尤其是在处理复杂类型或模板编程时。使用auto可以避免编写冗长的类型声明，同时减少由于类型不匹配导致的编译错误
auto x = 5; // x 的类型是 int auto y = 3.14; // y 的类型是 double auto z = 'a'; // z 的类型是 char // 指针 int* p = &x; auto p1 = &x; // p1 的类型是 int* // 引用 auto& r = x; // r 是 x 的引用，类型为 int& // 复杂的类型推导 std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}}; auto iter = myMap.begin(); // iter 的类型是 std::map<int, std::string>::iterator注意事项：
初始化：使用
auto声明的变量必须被初始化，因为编译器需要依据初始化表达式来推导类型。指针和引用：可以通过在
auto后面添加*或&来声明指针或引用类型的变量。- 范围for循环：
auto在范围for循环中非常有用，因为它可以自动处理迭代器的类型。std::vector<int> v = {1, 2, 3, 4, 5}; for (auto i : v) { // i 的类型是 int，并且是 v 中元素的拷贝 } for (auto& i : v) { // i 是对 v 中元素的引用，可以修改 v 中的元素 }
- 模版编程：在模板编程中，
auto尤其有用，因为它可以帮助避免编写复杂的类型声明
using namespace std; int add(int *a,int *b) { ++ *a; ++ *b; return *a + *b; } int main() { int i =10,j =9; cout << add(&i,&j) <<endl; cout << i <<"," << j <<endl; }
引用 &
- 定义引用：
int a = 10 ;
int & b = a ; // b是a的引用b和a指向内存中的同一个位置。对b的任何非const修改都会反映到a上。引用的限制：
引用在定义时必须被初始化。
引用一旦被初始化，就不能再改变为引用另一个对象。
引用不能为空函数参数和返回值中的引用
引用常用于函数参数和返回值中，以实现高效的数据传递和返回,
------ 函数参数：通过引用传递参数可以避免拷贝大型对象，提高程序效率。
void swap(int& a, int& b) { int temp = a; a = b; b = temp; }------ 函数返回值：通过引用返回可以避免拷贝，但需要注意避免返回局部变量的引用，因为这会导致悬垂引用
int& findMax(int& a, int& b) { return (a > b) ? a : b; }常量引用：
常量引用允许我们引用一个常量对象或非常量对象，但不允许我们通过这个引用来修改对象的值
const int c = 30; const int& d = c; // 正确：d是c的常量引用 int& e = c; // 错误：不能通过非常量引用来引用常量对象
简述指针与引用的关系？
相同点：
间接访问：两者都允许通过它们来访问和操作另一个变量的值，而不是直接访问该变量的内存地址。
函数参数：在函数中，使用指针或引用作为参数可以避免复制大型对象，提高效率，并且允许函数修改传入的变量的值。
返回非局部变量的值：都可以用来从函数中返回非局部变量的地址或引用，从而允许在函数外部访问和修改这些变量的值。
不同点：
（1）语法：
- 指针需要解引用（使用
*操作符）来访问其指向的值。- 引用则像是一个变量的别名，不需要特殊的操作符来访问其值。
（2）空值：
- 指针可以被设置为
nullptr（或NULL，在C++11之前），表示它不指向任何对象。- 引用必须在声明时被初始化，且一旦被绑定到一个对象，就不能再被改变为引用另一个对象，即引用不能为空。
（3) 赋值
- 指针可以被重新赋值以指向另一个对象。
- 引用一旦绑定到一个对象，就不能再指向另一个对象。
（3）类型安全：
- 指针可以进行算术运算（如递增或递减），这可能导致它指向无效的内存区域，降低类型安全性。
- 引用不支持算术运算，这增加了类型安全性，但同时限制了灵活性。
（4）大小
- 指针本身是一个变量，它存储的是另一个变量的内存地址，因此指针有大小（通常是机器字长）。
- 引用则是一个别名，不占用额外的存储空间（不存储地址，只是别名），但从实现的角度来看，编译器可能会以指针的形式来处理引用。
（5）使用场景：
- 指针因其灵活性（如动态内存分配、数组操作、链表等数据结构）而被广泛使用。
- 引用则因其安全性和简洁性（如函数参数传递、返回值等）而在C++中被推荐用于需要引用语义的场合。
内联函数 inline
定义：
inline 是一种建议 不是命令，是否真的展开取决于编译器
声明：
内联函数的 inline 关键字只放在头文件不放在源文件中
虽然可以在函数声明前添加
inline关键字，但这种方式通常是无效的，因为编译器在编译时只关注函数定义处的inline关键字。因此，通常将inline关键字与函数定义体放在一起特点：
- 编译时展开：内联函数在编译时会被直接插入到调用该函数的地方，而不是像普通函数那样生成函数调用的指令。这消除了函数调用的开销，包括参数传递、栈帧创建和销毁等。
#include <iostream> // 声明内联函数 inline int max(int a, int b) { return (a > b) ? a : b; } int main() { int x = 5, y = 10, z; z = max(x, y); // 这里调用max函数，编译器可能会将其内联展开 std::cout << "The maximum is " << z << std::endl; return 0; }- 适用于简单函数：内联函数通常适用于函数体较小、执行时间较短的函数。如果函数体过大或包含复杂的控制结构（如循环、递归等），编译器可能不会将其内联，因为这可能导致代码膨胀和性能下降。
- 代码膨胀：由于内联函数的代码会被复制到每一个调用处，因此如果内联函数被频繁调用或代码较大，可能会导致程序体积增大。
- 通常放在头文件中：为了避免链接错误，内联函数的定义通常放在头文件中，以便在需要调用的地方进行内联展开。
例如：
inline void fm(int &n) { ++n; } int main() { int i =10; int j =20; fm(i); cout<< i <<endl; }inline void fm(const int &n) { n; } int main() { int i =10; fm(10); cout<< i <<endl; }结果：11
10
默认形参值
默认形参值只放在声明不放在定义
注意点：
默认值的位置：一旦你为某个参数指定了默认值，那么该参数之后的所有参数都必须有默认值。
int add ( int a = 0 , int b = 0 ) { cout << "a = " << a <<endl; cout << "b = " << b <<endl; return a + b ; } int main() { cout << add() << endl;//可以传参一可以不传参，如果不传参则都为0 //cout << add(10,20) << endl; return 0; } 结果：a = 0 ,b = 0 ,0 a = 10,b = 20 , 30
函数声明与定义：通常，在函数声明中指定默认值，并在函数定义中省略这些值。但是，你也可以在函数定义中直接指定默认值，只要确保在调用函数之前，编译器已经看到了这些默认值（即，函数声明或定义在调用点之前）。
头文件与源文件：如果函数声明在头文件中，而定义在源文件中，那么默认值应该在头文件的函数声明中指定。
重载与默认参数：具有默认参数的函数可以被重载。编译器会根据提供的参数数量和类型来选择最合适的函数版本。
函数指针与默认参数：当通过函数指针调用函数时，默认参数不会生效。你需要显式地提供所有参数。
构造函数与默认参数：类的构造函数也可以有默认参数，这对于创建具有可选成员变量的对象非常有用。
函数重载
函数重载的基本规则
- 函数名相同：重载的函数必须具有相同的名称。
- 参数列表不同：函数的参数列表必须不同。这可以是参数的类型不同、参数的个数不同，或者参数的顺序不同（尽管在实际应用中，改变参数顺序通常不是一个好的设计选择，因为它可能导致代码难以理解和维护）。
- 返回类型可以相同也可以不同：返回类型不是决定函数是否重载的因素。但是，习惯上，如果函数的功能相似，那么最好保持返回类型也一致，以增强代码的可读性。
- 仅返回类型不同不足以构成重载：如果两个函数只是返回类型不同，但参数列表完全相同，则编译器会报错，因为这不是有效的重载。
#include <iostream> using namespace std; //函数重载示例 同名但不同参 void print(int i) { cout << "Printing int: " << i << endl; } void print(double f) { cout << "Printing float: " << f << endl; } void print(const char* c) { cout << "Printing character: " << c << endl; } int main() { print(7); //调用 print(int) print(7.7); //调用 print(double) print("Hello"); //调用 print(const char*) return 0; }
const
const关键字是一个非常重要的特性，它用于指定变量的值在初始化之后不能被修改。const可以应用于变量、指针、函数参数、返回值等多种情况，以提高代码的可读性和安全性
- 修饰变量
当const用于修饰变量时，表示该变量的值是一个常量，在程序运行过程中不能被修改修饰指针
（1）指向常量的指针（指针指向的值不能被修改）const int* ptr = &x; // ptr是一个指向整数的指针，但这个整数是const的，即*ptr的值不能被修改（2）常量指针（指针指向的值不能被修改，但指向的值可以改变）
int* const ptr = &x; // ptr是一个const指针，指向x，但ptr本身的值（即它所指向的地址）不能被修改（3）同时修饰指针和指向的值：
const int* const ptr = &x; // ptr是一个const指针，指向一个const整数，即ptr的值和*ptr的值都不能被修改修饰函数参数
在函数定义中，使用const修饰参数可以告诉调用者这个参数在函数内部不会被修改，这有助于编译器进行优化，并增加了代码的清晰度
void display(const int& x) { // 在这里，你不能修改x的值 cout << x << endl; }修饰返回值
const也可以用于修饰函数的返回值，但这种情况比较少见。当const用于修饰返回值时，它表示返回的对象是一个常量，调用者不能通过这个返回值去修改对象的状态
const int getValue() { // 返回一个常量int return 42; } // 注意，对于自定义类型（如类），返回const对象通常是为了表示这个对象是只读的，不应该被修改 const MyClass getMyClassInstance() { // ... }然而，对于自定义类型（如类）的返回值，如果返回的是对象本身而不是引用或指针，那么
const修饰符可能并不那么有用，因为返回值是一个临时对象，它本身就不能被赋值给非const的变量（这会导致拷贝）。但如果是返回引用或指针，那么const修饰符就显得非常重要了成员函数
在类中，const成员函数表示该函数不会修改类的任何成员变量（除了mutable修饰的成员变量）。这有助于保证对象的状态在调用该函数后不会发生变化class MyClass { public: void myFunction() const { // 这里不能修改类的成员变量 } };
不能实现
常引用
void（const int &a）
常引用通过在类型前添加
const关键字来声明。常引用只能用于读取它所引用的数据，而不能用于修改。这使得常引用在以下场景中特别有用：
- 保护数据：当你想要通过函数参数传递一个对象，但又不希望这个函数修改这个对象时，可以使用常引用。
- 提高效率：对于大型对象或容器，通过引用传递可以避免不必要的复制，同时
const修饰符又保证了数据的安全性。- 函数返回值：返回对内部成员或局部静态变量的常引用可以避免拷贝，并保护这些变量不被外部修改。
非常引用（或者普通引用）
void (int &a)
没有
const修饰的引用就是非常引用或普通引用。它允许通过引用修改它所引用的数据。非常引用在需要修改数据的函数中非常有用，因为它们提供了对原始数据的直接访问
#include <iostream> using namespace std; void printValue(const int& x) { // 使用常引用接收参数，保证不会修改x cout << x << endl; } void modifyValue(int& x) { // 使用非常引用接收参数，可以修改x x = 10; } int main() { int a = 5; printValue(a); // 输出5 modifyValue(a); // 修改a的值为10 printValue(a); // 现在输出10 return 0; }
