c++内联函数
内联函数与其他函数的区别（这必须深入到程序的内部）：编译的最终产品是可执行程序-----它是由机械语言指令组成。运行时程序，操作系统会把这些指令载入到计算机内存中，分配内存逐步执行。在调用函数时，函数会立即保存该指令地址，并且把参数复制到栈堆（为此保留内存块），调到函数的起点的内存单元执行代码，也许还需将返回值放入寄存器中，跳回到地址保存指令处。而内联函数不需要这样，但是需要占用大量的内存。
写法：需要在申明和定义前加上inline。
#include <iostream>class MyClass {
public:// 声明时可以加 inlineinline int add(int a, int b);
};// 定义时必须加 inline 才能成为内联函数
inline int MyClass::add(int a, int b) {return a + b;
}int main() {MyClass obj;std::cout << obj.add(3, 4) << std::endl;return 0;
}引用变量
引用必须进行初始化。
这里说明了引用具有唯一性（不会因为后面的改变而改变一开始引用的值）。
int main()
{
int tmp = 100;
int* ptr = &tmp;
int& ter = *ptr;
cout <<"&tmp" << & tmp << endl;
cout <<"&ptr" << & ptr << endl;
cout << "ter" << ter << &ter<< endl;
int tmp1 = 200;
int* ter1 = &tmp1;
ter = *ter1;
cout << "ter" << ter << &ter << endl;
}
引用和取地址传参一样可以改变它本身的字值。但需要记住引用传参的和普通函数传参一样。
#include <iostream>// 传值方式交换函数
void swapByValue(int a, int b) {int temp = a;a = b;b = temp;
}// 指针方式交换函数
void swapByPointer(int* a, int* b) {int temp = *a;*a = *b;*b = temp;
}// 引用方式交换函数
void swapByReference(int& a, int& b) {int temp = a;a = b;b = temp;
}int main() {int num1 = 10;int num2 = 20;// 传值方式交换测试std::cout << "传值方式交换：" << std::endl;std::cout << "交换前: num1 = " << num1 << ", num2 = " << num2 << std::endl;swapByValue(num1, num2);std::cout << "交换后: num1 = " << num1 << ", num2 = " << num2 << std::endl;// 重置 num1 和 num2 的值num1 = 10;num2 = 20;// 指针方式交换测试std::cout << "\n指针方式交换：" << std::endl;std::cout << "交换前: num1 = " << num1 << ", num2 = " << num2 << std::endl;swapByPointer(&num1, &num2);std::cout << "交换后: num1 = " << num1 << ", num2 = " << num2 << std::endl;// 重置 num1 和 num2 的值num1 = 10;num2 = 20;// 引用方式交换测试std::cout << "\n引用方式交换：" << std::endl;std::cout << "交换前: num1 = " << num1 << ", num2 = " << num2 << std::endl;swapByReference(num1, num2);std::cout << "交换后: num1 = " << num1 << ", num2 = " << num2 << std::endl;return 0;
}传值方式交换：
交换前: num1 = 10, num2 = 20
交换后: num1 = 10, num2 = 20指针方式交换：
交换前: num1 = 10, num2 = 20
交换后: num1 = 20, num2 = 10引用方式交换：
交换前: num1 = 10, num2 = 20
交换后: num1 = 20, num2 = 10使用const引用的三大好处
（1）使用const可以避免无意间修改了数据。
（2）使用const使用函数时可以使用const和非const的实参，否则只能接收非const的数据。
（3）使用const引用能让函数正确的生成并使用临时变量。
引用结构体时你需要在申明时进行引用
默认参数：
在函数定义时，可以为函数的参数进行赋值（也可以跳着赋值）。但是需要注意实参给形参传值时只能从左到右依次进行，不能跳过赋值。
#include <iostream>// 定义一个带有默认参数的函数
int add(int a, int b = 10) {return a + b;
}int main() {// 调用函数时提供两个参数int result1 = add(5, 20);std::cout << "Result with two arguments: " << result1 << std::endl;// 调用函数时只提供一个参数，b 使用默认值 10int result2 = add(5);std::cout << "Result with one argument: " << result2 << std::endl;return 0;
}函数重载：
函数名相同，函数参数的数量，类型，是否加const，顺序不同为函数重载。
原理：编译器是根据实参的类型不同和个数不同，去参数列表来匹配对应的函数进行调用。
#include <iostream>// 计算两个整数的和
int add(int a, int b) {return a + b;
}// 计算三个整数的和
int add(int a, int b, int c) {return a + b + c;
}// 计算两个双精度浮点数的和
double add(double a, double b) {return a + b;
}int main() {// 调用两个整数相加的函数int result1 = add(1, 2);std::cout << "1 + 2 = " << result1 << std::endl;// 调用三个整数相加的函数int result2 = add(1, 2, 3);std::cout << "1 + 2 + 3 = " << result2 << std::endl;// 调用两个双精度浮点数相加的函数double result3 = add(1.5, 2.5);std::cout << "1.5 + 2.5 = " << result3 << std::endl;return 0;
}何时使用函数重载：当函数基本执行任务相同时但使用不同类型的数据时，采用函数重载。
函数模版
template<typename T>
void sweap(T& x, T& y)
{
T temp = x;
x = y;
y = temp;
}
第一行的代码，关键字template，typename，尖括号是必须的，可以使用class来代替typename。后面的T可以使用任意的名称（但是要符合c++的取名规范）。
实例化和具体化
template 返回类型 模板名<特定类型>(参数列表); // 函数模板显式实例化
template class 类模板名<特定类型>; // 类模板显式实例化#include <iostream>// 函数模板
template <typename T>
T add(T a, T b) {return a + b;
}// 类模板
template <typename T>
class Container {
private:T value;
public:Container(T val) : value(val) {}T getValue() const {return value;}
};// 函数模板显式实例化
template int add<int>(int, int);
// 类模板显式实例化
template class Container<double>;int main() {int result = add(1, 2);std::cout << "1 + 2 = " << result << std::endl;Container<double> container(3.14);std::cout << "Container value: " << container.getValue() << std::endl;return 0;
}警告：试图在同一个文件（或转换单元格）中使用同一种类型的显示实例化和显示具体化将会出错。
