当前位置：首页 > news >正文

#函数探幽

news 来源：原创 2025/5/9 19:30:00

c++内联函数

内联函数与其他函数的区别（这必须深入到程序的内部）：编译的最终产品是可执行程序-----它是由机械语言指令组成。运行时程序，操作系统会把这些指令载入到计算机内存中，分配内存逐步执行。在调用函数时，函数会立即保存该指令地址，并且把参数复制到栈堆（为此保留内存块），调到函数的起点的内存单元执行代码，也许还需将返回值放入寄存器中，跳回到地址保存指令处。而内联函数不需要这样，但是需要占用大量的内存。

写法：需要在申明和定义前加上inline。

#include <iostream>

class MyClass {
public:
    // 声明时可以加 inline
    inline 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 使用默认值 10
    int 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;
}

警告：试图在同一个文件（或转换单元格）中使用同一种类型的显示实例化和显示具体化将会出错。