C++ 函数全解

最新推荐文章于 2025-03-17 16:48:04 发布
最新推荐文章于 2025-03-17 16:48:04 发布
阅读量1.6k 收藏 18
点赞数 32
文章标签： c++ 算法 开发语言 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_81482480/article/details/143990022
版权

引言

在C++编程中，函数是程序的基本构建块之一。函数可以将代码组织成可重用的模块，提高代码的可读性和可维护性。本文将详细介绍C++函数的各种特性，包括函数的定义、调用、参数传递、返回值、重载、内联函数、递归函数、函数指针、Lambda 函数、模板函数和函数对象。

1. 函数的定义

1.1 基本语法

函数的基本定义语法如下：

返回类型 函数名(参数列表) {
    // 函数体
}
  • 返回类型：函数执行后返回的数据类型。如果函数不返回任何值，使用 void。
  • 函数名：函数的名称，用于调用函数。
  • 参数列表：函数接受的参数，可以为空。
  • 函数体：函数的具体实现。

1.2 示例

int add(int a, int b) {
    return a + b;
}

1.3 函数声明与定义

函数可以在声明后定义，也可以在定义时声明。声明通常放在头文件中，定义放在源文件中。

// 声明
int add(int a, int b);

// 定义
int add(int a, int b) {
    return a + b;
}

2. 函数的调用

2.1 基本调用

函数调用时，需要提供与参数列表匹配的参数。

int result = add(3, 5); // result = 8

2.2 函数调用的执行过程

  1. 参数传递：将实际参数传递给函数的形参。
  2. 执行函数体：执行函数体中的代码。
  3. 返回结果：函数执行完毕后，返回结果（如果有）。

2.3 函数调用的栈帧

每次调用函数时，系统会在栈上为该函数分配一个栈帧，用于存储函数的局部变量和参数。函数调用结束后，栈帧被释放。

3. 参数传递

3.1 按值传递

按值传递是指将实际参数的值复制给形参。形参的任何修改都不会影响实际参数。

void modifyValue(int x) {
    x = 10;
}

int main() {
    int a = 5;
    modifyValue(a);
    std::cout << a << std::endl; // 输出 5
    return 0;
}

3.2 按引用传递

按引用传递是指将实际参数的引用传递给形参。形参的任何修改都会影响实际参数。

void modifyValue(int& x) {
    x = 10;
}

int main() {
    int a = 5;
    modifyValue(a);
    std::cout << a << std::endl; // 输出 10
    return 0;
}

3.3 按指针传递

按指针传递是指将实际参数的地址传递给形参。通过指针可以修改实际参数。

void modifyValue(int* x) {
    *x = 10;
}

int main() {
    int a = 5;
    modifyValue(&a);
    std::cout << a << std::endl; // 输出 10
    return 0;
}

3.4 默认参数

默认参数是指在函数声明中为参数提供默认值。如果调用函数时没有提供相应的参数，将使用默认值。

void greet(std::string name, std::string greeting = "Hello") {
    std::cout << greeting << ", " << name << "!" << std::endl;
}

int main() {
    greet("Alice"); // 输出 "Hello, Alice!"
    greet("Bob", "Hi"); // 输出 "Hi, Bob!"
    return 0;
}

3.5 可变参数

可变参数函数可以接受不同数量的参数。C++11 引入了 std::initializer_list 和变长模板来实现可变参数。

void printNumbers(std::initializer_list<int> numbers) {
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main() {
    printNumbers({1, 2, 3, 4, 5}); // 输出 "1 2 3 4 5 "
    return 0;
}

3.6 常量引用参数

常量引用参数可以防止函数修改传入的参数。

void print(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::string msg = "Hello, World!";
    print(msg); // 输出 "Hello, World!"
    return 0;
}

4. 返回值

4.1 基本返回值

函数可以返回一个值，返回值的类型在函数声明时指定。

int add(int a, int b) {
    return a + b;
}

4.2 多返回值

C++ 不直接支持多返回值，但可以通过返回结构体或元组来实现。

#include <tuple>

std::tuple<int, int> addAndSubtract(int a, int b) {
    return std::make_tuple(a + b, a - b);
}

int main() {
    int sum, diff;
    std::tie(sum, diff) = addAndSubtract(10, 5);
    std::cout << "Sum: " << sum << ", Difference: " << diff << std::endl; // 输出 "Sum: 15, Difference: 5"
    return 0;
}

4.3 返回引用

函数可以返回引用，允许调用者修改返回的值。

int& getMax(int& a, int& b) {
    return (a > b) ? a : b;
}

int main() {
    int x = 10, y = 20;
    getMax(x, y) = 30;
    std::cout << "x: " << x << ", y: " << y << std::endl; // 输出 "x: 10, y: 30"
    return 0;
}

4.4 返回指针

函数可以返回指针，但需要注意指针的有效性。

int* createArray(int size) {
    int* arr = new int[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = i;
    }
    return arr;
}

int main() {
    int* arr = createArray(5);
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    delete[] arr; // 释放内存
    return 0;
}

5. 函数重载

5.1 基本概念

函数重载是指在同一个作用域中定义多个同名函数，但参数列表不同。编译器根据参数列表选择合适的函数。

void print(int x) {
    std::cout << "Integer: " << x << std::endl;
}

void print(double x) {
    std::cout << "Double: " << x << std::endl;
}

int main() {
    print(5); // 调用 print(int)
    print(5.0); // 调用 print(double)
    return 0;
}

5.2 重载规则

  • 参数列表必须不同。
  • 返回类型不同不能作为重载的依据。
  • 参数的常量性和引用性可以作为重载的依据。

5.3 重载示例

void print(const char* str) {
    std::cout << "String: " << str << std::endl;
}

void print(const std::string& str) {
    std::cout << "String: " << str << std::endl;
}

int main() {
    print("Hello"); // 调用 print(const char*)
    print(std::string("World")); // 调用 print(const std::string&)
    return 0;
}

6. 内联函数

6.1 基本概念

内联函数是一种优化手段，编译器会在调用点直接插入函数体，避免函数调用的开销。

inline int add(int a, int b) {
    return a + b;
}

6.2 使用场景

  • 函数体非常短小。
  • 调用频繁。

6.3 内联函数的限制

  • 内联函数的定义必须在所有调用点之前可见。
  • 过多的内联函数可能会增加编译时间和可执行文件的大小。

7. 递归函数

7.1 基本概念

递归函数是指在函数体中调用自身的函数。递归函数需要有一个终止条件，否则会导致无限递归。

int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    std::cout << "Factorial of 5: " << factorial(5) << std::endl; // 输出 "Factorial of 5: 120"
    return 0;
}

7.2 递归优化

  • 尾递归：如果递归调用是函数的最后一个操作，编译器可以优化为循环，避免栈溢出。
int factorial(int n, int result = 1) {
    if (n == 0) {
        return result;
    }
    return factorial(n - 1, n * result);
}

int main() {
    std::cout << "Factorial of 5: " << factorial(5) << std::endl; // 输出 "Factorial of 5: 120"
    return 0;
}

7.3 递归示例：斐波那契数列

int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    std::cout << "Fibonacci of 5: " << fibonacci(5) << std::endl; // 输出 "Fibonacci of 5: 5"
    return 0;
}

8. 函数指针

8.1 基本概念

函数指针是指向函数的指针，可以用来调用函数。

int add(int a, int b) {
    return a + b;
}

int main() {
    int (*func)(int, int) = add; // 声明并初始化函数指针
    int result = func(3, 5); // 调用函数
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 8"
    return 0;
}

8.2 函数指针数组

可以使用函数指针数组来存储多个函数指针。

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    int (*funcArray[2])(int, int) = {add, subtract}; // 函数指针数组
    int result1 = funcArray[0](3, 5); // 调用 add
    int result2 = funcArray[1](3, 5); // 调用 subtract
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl; // 输出 "Result1: 8, Result2: -2"
    return 0;
}

8.3 函数指针作为参数

可以将函数指针作为参数传递给其他函数。

void applyFunction(int (*func)(int, int), int a, int b) {
    int result = func(a, b);
    std::cout << "Result: " << result << std::endl;
}

int main() {
    applyFunction(add, 3, 5); // 输出 "Result: 8"
    applyFunction(subtract, 3, 5); // 输出 "Result: -2"
    return 0;
}

8.4 函数指针的类型别名

可以使用 typedef 或 using 关键字为函数指针创建类型别名。

typedef int (*FuncPtr)(int, int);

void applyFunction(FuncPtr func, int a, int b) {
    int result = func(a, b);
    std::cout << "Result: " << result << std::endl;
}

int main() {
    applyFunction(add, 3, 5); // 输出 "Result: 8"
    applyFunction(subtract, 3, 5); // 输出 "Result: -2"
    return 0;
}

9. Lambda 函数

9.1 基本概念

Lambda 函数是一种匿名函数，可以在需要函数的地方直接定义和使用。

int main() {
    auto add = [](int a, int b) -> int {
        return a + b;
    };

    int result = add(3, 5);
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 8"
    return 0;
}

9.2 Lambda 的捕获列表

Lambda 函数可以捕获外部变量，使用捕获列表来指定捕获方式。

int main() {
    int x = 10;
    auto add = [x](int a) -> int {
        return a + x;
    };

    int result = add(5);
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 15"
    return 0;
}

9.3 Lambda 作为参数

Lambda 函数可以作为参数传递给其他函数。

void applyFunction(std::function<int(int, int)> func, int a, int b) {
    int result = func(a, b);
    std::cout << "Result: " << result << std::endl;
}

int main() {
    applyFunction([](int a, int b) -> int { return a + b; }, 3, 5); // 输出 "Result: 8"
    applyFunction([](int a, int b) -> int { return a - b; }, 3, 5); // 输出 "Result: -2"
    return 0;
}

9.4 Lambda 的捕获方式

  • 按值捕获：[x]，捕获 x 的值。
  • 按引用捕获：[&x]，捕获 x 的引用。
  • 捕获所有局部变量：[=]，按值捕获所有局部变量。
  • 捕获所有局部变量的引用：[&]，按引用捕获所有局部变量。

10. 模板函数

10.1 基本概念

模板函数可以处理不同类型的参数，提高代码的通用性。

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int result1 = add(3, 5); // 输出 "Result1: 8"
    double result2 = add(3.0, 5.0); // 输出 "Result2: 8.0"
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl;
    return 0;
}

10.2 模板特化

可以为特定类型提供模板特化，实现特定类型的优化。

template <>
int add<int>(int a, int b) {
    return a + b + 1; // 特化版本
}

int main() {
    int result1 = add(3, 5); // 输出 "Result1: 9"
    double result2 = add(3.0, 5.0); // 输出 "Result2: 8.0"
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl;
    return 0;
}

10.3 模板参数

模板参数可以是类型参数，也可以是非类型参数。

template <typename T, int N>
T multiply(T a) {
    return a * N;
}

int main() {
    int result1 = multiply<int, 5>(3); // 输出 "Result1: 15"
    double result2 = multiply<double, 2>(3.0); // 输出 "Result2: 6.0"
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl;
    return 0;
}

11. 函数对象

11.1 基本概念

函数对象是指重载了 operator() 的类对象，可以像函数一样调用。

class Add {
public:
    int operator()(int a, int b) {
        return a + b;
    }
};

int main() {
    Add add;
    int result = add(3, 5);
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 8"
    return 0;
}
``

11. 函数对象

11.2 函数对象的捕获

函数对象可以捕获外部变量，类似于Lambda函数。这可以通过在类中使用成员变量来实现。

class Add {
private:
    int base;
public:
    Add(int base) : base(base) {}

    int operator()(int a) {
        return a + base;
    }
};

int main() {
    Add add(10);
    int result = add(5);
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 15"
    return 0;
}
11.3 函数对象的灵活性

函数对象可以提供更多的灵活性，例如可以包含多个操作或状态。

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }

    int subtract(int a, int b) {
        return a - b;
    }
};

int main() {
    Calculator calc;
    int result1 = calc.add(3, 5);
    int result2 = calc.subtract(3, 5);
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl; // 输出 "Result1: 8, Result2: -2"
    return 0;
}

12. 函数的高级用法

12.1 函数模板的默认参数

模板函数可以有默认参数，类似于普通函数。

template <typename T, int N = 2>
T multiply(T a) {
    return a * N;
}

int main() {
    int result1 = multiply<int>(3); // 使用默认参数 N = 2
    int result2 = multiply<int, 5>(3); // 指定参数 N = 5
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl; // 输出 "Result1: 6, Result2: 15"
    return 0;
}
12.2 函数模板的显式特化

可以为特定类型提供显式特化，实现特定类型的优化。

template <typename T>
T add(T a, T b) {
    return a + b;
}

template <>
int add<int>(int a, int b) {
    return a + b + 1; // 特化版本
}

int main() {
    int result1 = add(3, 5); // 输出 "Result1: 9"
    double result2 = add(3.0, 5.0); // 输出 "Result2: 8.0"
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl;
    return 0;
}
12.3 函数模板的部分特化

部分特化允许为特定类型的一部分提供特化版本。

template <typename T, typename U>
struct Add {
    static T add(T a, U b) {
        return a + b;
    }
};

template <typename T>
struct Add<T, int> {
    static T add(T a, int b) {
        return a + b + 1; // 特化版本
    }
};

int main() {
    int result1 = Add<int, int>::add(3, 5); // 输出 "Result1: 9"
    double result2 = Add<double, double>::add(3.0, 5.0); // 输出 "Result2: 8.0"
    std::cout << "Result1: " << result1 << ", Result2: " << result2 << std::endl;
    return 0;
}

13. 函数的最佳实践

13.1 函数的命名

函数的命名应该清晰、简洁，能够反映其功能。使用动词或动词短语来命名函数。

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}
13.2 函数的长度

函数应该保持简短，通常不超过20行代码。如果函数过长，可以考虑将其拆分为多个函数。

void processRequest(const std::string& request) {
    parseRequest(request);
    validateRequest(request);
    executeRequest(request);
}

void parseRequest(const std::string& request) {
    // 解析请求
}

void validateRequest(const std::string& request) {
    // 验证请求
}

void executeRequest(const std::string& request) {
    // 执行请求
}
13.3 函数的参数

尽量减少函数的参数数量。如果参数过多，可以考虑使用结构体或类来传递参数。

struct Request {
    std::string url;
    std::string method;
    std::map<std::string, std::string> headers;
};

void processRequest(const Request& request) {
    // 处理请求
}
13.4 函数的返回值

函数的返回值应该明确，避免使用全局变量或外部状态来传递结果。

int add(int a, int b) {
    return a + b;
}
13.5 函数的错误处理

函数应该有明确的错误处理机制，可以使用异常、错误码或可选类型来处理错误。

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero");
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0);
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cout << "Error: " << e.what() << std::endl;
    }
    return 0;
}

14. 总结

C++函数是程序设计中的重要组成部分，通过合理地使用函数，可以提高代码的可读性、可维护性和可重用性。本文详细介绍了C++函数的各种特性，包括函数的定义、调用、参数传递、返回值、重载、内联函数、递归函数、函数指针、Lambda函数、模板函数和函数对象。希望本文能够帮助您更好地理解和使用C++函数。

C++函数
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-04 281
6 函数 6.1 概述 **作用：**将一段经常使用的代码封装起来，减少重复代码 一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。 6.2 函数的定义 函数的定义一般主要有5个步骤： 1、返回值类型 2、函数名 3、参数表列 4、函数体语句 5、return 表达式 语法： 返回值类型 函数名 （参数列表） { 函数体语句 return表达式 } 返回值类型 ：一个函数可以返回一个值。在函数定义中 函数名：给函数起个名称 参数列表：使用该函数时，传入的数据
【C++】find() 函数全解
禅宗里有一个词叫做“因缘和合”。 所谓因缘，是指事件要发生所必须的条件。因缘和合就是当你聚集了这件事的一切条件，它就会自然而然的发生。“它就会自然而然的发生”，这种朴素而坚定的价值观让我们感到无比安心，安心到可以不用有任何担心焦虑。
01-12 4330
C++计算机软件开发中，对字符串进行操作是常见的需求。字符串里的查询功能是基础，也是高性能编程中的重要一环。C++ 中提供了完善的字符串操作函数，而其中的 find() 函数，是用于在字符串中查找子串或字符的工具。 本文将全面解析 C++ 中的 find() 函数，包括基础解释，示例解析，以及实际应用中的特别经验。我们将重点解析不同功能开发情景中的实现，并提供简单明显的实验代码。 2025.1.12-✍66min
c++中的函数
m0_64703222的博客
04-24 2082
返回值类型函数名参数列表函数体语句return表达式注意：函数不能写到main函数中去//函数定义//语法//返回值类型 函数名（ 参数列表）{ 函数体语句 return表达式}//加法函数，实现两个整型相加，并且将相加的结果进行返回return sum;//主函数return 0;
【C++基础】函数介绍
最新发布
分享是一种境界，勤于分享，乐于分享！
03-17 861
函数是C++程序的核心组成部分，用于封装可重复使用的代码逻辑。本文将系统介绍C++函数的定义、调用、参数传递、重载机制及高级特性等等，通过实际代码示例展示其应用场景。众所周知，C++ 是一种‌通用、高性能的编程语言‌，支持‌多范式编程‌（面向对象、泛型、过程化），由本贾尼·斯特劳斯特卢普（ ‌‌ ）于 1985 年基于 C 语言扩展而来。官网地址：https://cplusplus.com/doc/参考手册：https://cppreference.cn/w/话不多说，我们一起进入正题吧。
C++ 函数
shouhu010的博客
02-10 2037
本文主要介绍C++中的函数用法，包括基本函数、函数重载、函数指针、指针函数、函数模块、回调函数、function、bind、lambda、内联函数、递归函数。
WinAPI与C++函数查询全解指南
根据给定的文件信息，可以了解到文件内容是关于Windows API（WinAPI）和C++函数的查询工具或资料集合，并且该资料以中英文版本结合的形式出现，方便不同语言需求的开发者使用。下面将详细说明与WinAPI和C++函数查询...
C++STL全解
04-03
### C++ STL 全解 #### 一、STL 概述 C++ Standard Template Library (STL) 是一种高效且具有工业级别的 C++ 库，它为开发者提供了一系列广泛使用的数据结构和算法。STL 的核心优势在于其**泛型编程**特性，即能够...
C++构造函数全解：掌握10个关键特性，避免性能陷阱（专家级指南）
[C++构造函数全解：掌握10个关键特性，避免性能陷阱（专家级指南）](https://www.learnovita.com/wp-content/uploads/2022/08/what-is-a-constructor-in-c.jpg) # 1. C++构造函数的定义与作用 在C++编程语言中，...
Linux C/C++编程全解：函数接口与开发指南
2. C语言编程技巧：涵盖了C语言的核心概念、数据类型、控制结构、函数使用、指针操作、动态内存分配等编程技巧。 3. Linux内核接口：详细介绍了Linux内核提供的各种系统调用（system call）、库函数（library ...
C++ 函数详解与示例
男Ren、麦根的博客
06-22 1805
函数体，定义函数的具体实现函数定义包括函数头和函数体。函数头指定了函数的返回类型、函数名和形式参数列表，函数体包含了实际的代码实现。通过本文的介绍，您应该已经掌握了C++中函数的定义、声明、调用、参数传递方式、函数重载和函数模板等重要概念。函数是C++编程中组织和结构化代码的关键工具，通过合理使用函数，可以使代码更加模块化、清晰和易于维护。在实际应用中，根据具体需求选择合适的函数形式，并灵活运用函数的特性，将有助于提高程序的可读性和开发效率。希望本文能够对您学习和应用C++函数有所帮助。
c++函数大全
你猜我是谁？
12-08 8199
函数是 C/C++语言中的一种程序组件单位。一个函数通常代表了一种数据处理的功能，由函数体和函数原型两部分组成。函数原型为这个数据处理功能指定一个标识符号(函数的名称)、说明被处理数据的组成及其类型、处理结果的类型。函数体由一组语句组成，具体实现数据处理的功能。这称为函数的定义。在某段程序中，一个函数可以被当作一个表达式来运行，称为函数的调用。函数的定义并不执行函数体中的语句，只是声明该函数包含这些语句、以及这些语句的运行顺序。函数在被调用之前，必须说明它的原型。被函数处理的数据一般作为函数的参数，在函数调
c++函数
m0_62870588的博客
04-08 3999
函数简介；函数的定义；函数调用；函数的作用域；函数的局部作用域；全局变量对函数的影响；函数作用域的综合示例；参数；实参与形参不匹配；返回值；错误使用返回值为void的函数；返回值为void的函数中提前返回；静态局部对象；
C++的函数
weixin_42284219的博客
02-28 294
八、C++的函数 1、函数重载 1）定义：在相同作用域，定义同名的函数，但是它们的参数要有所区分，这样的多个函数构成重载关系。 注：函数的重载和返回值无关 eg：图形库（包含很多绘图函数） //C语言实现 void drawCircle(int x, int y, double r){//......} void drawRect(int x, int y, double w, double h)...
C++中的各类函数详解
qxt1508520947的博客
02-17 9076
C++中的函数主要分为以下几类：内置函数、标准库函数、用户自定义函数、成员函数、虚函数和函数模板。下面分别介绍这些函数的特点和用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值