【C++进阶】函数：深度解析 C++ 函数的 12 大进化特性

// 函数声明
int add(int a, int b);
 
// 函数定义
int add(int a, int b) {
    return a + b;
}

#include <iostream>

// 用户自定义类型：二维点
struct Point {
    int x;
    int y;
    
    // 成员函数示例
    void print() {
        std::cout << "(" << x << ", " << y << ")\n";
    }
};

// 函数声明（参数和返回类型均为自定义类型）
Point addPoints(const Point& a, const Point& b);

int main() {
    // 创建自定义类型对象
    Point p1 = {1, 2};
    Point p2 = {3, 4};
    
    // 调用自定义类型参数的函数
    Point result = addPoints(p1, p2);
    
    // 使用自定义类型的成员函数
    result.print();  // 输出：(4, 6)
    return 0;
}

// 函数定义（实现细节）
Point addPoints(const Point& a, const Point& b) {
    Point sum;
    sum.x = a.x + b.x;
    sum.y = a.y + b.y;
    return sum;
}

// C语言中的函数调用
int result = add(3, 4);

// C++中的函数调用
int result = add(3, 4);

#include <iostream>

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    std::cout << "Before: x=" << x << ", y=" << y << std::endl;
    swap(x, y);
    std::cout << "After:  x=" << x << ", y=" << y << std::endl;
    return 0;
}

#include <iostream>

// C++支持重载，C语言禁止
void print(int x) { std::cout << "int: " << x << '\n'; }
void print(double x) { std::cout << "double: " << x << '\n'; }
void print(const char* s) { std::cout << "string: " << s << '\n'; }

int main() {
    print(42);       // int: 42
    print(3.14);     // double: 3.14
    print("Hello");  // string: Hello
}

void f(int x, int y = 0); // 声明带默认参数
void f(int x, int y);    // 定义不带默认参数（C++允许，但调用时按声明处理）

#include <iostream>
using namespace std;

// 定义函数，为参数b和c指定默认值
int add(int a, int b = 5, int c = 10) {
    return a + b + c;
}

int main() {
    cout << "add(3) = " << add(3) << endl;       // 使用默认值：b=5, c=10
    cout << "add(3, 7) = " << add(3, 7) << endl;  // 使用默认值：c=10
    cout << "add(3, 7, 2) = " << add(3, 7, 2) << endl; // 不使用默认值
    return 0;
}

// C语言通过宏模拟默认参数
#define SET_CONFIG(port, host) set_config((port) ? (port) : 8080, (host) ? (host) : "localhost")
void set_config(int port, const char* host); // 无默认参数

// 强制内联（GCC/Clang扩展）
[[gnu::always_inline]] 
void fast_math(float& x) { x *= 1.618f; } // 高频调用的数学函数

#include <iostream>
using namespace std;

// 使用inline关键字声明内联函数
inline int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    cout << "max(3, 4) = " << max(3, 4) << endl;
    return 0;
}

constexpr int square(int x) { return x * x; } // 编译期计算
constexpr auto arr = {square(2), square(3)}; // 编译期初始化数组

constexpr int fib(int n) {
    return n <= 1 ? n : fib(n-1) + fib(n-2); // 编译期计算
}
constexpr int fib_42 = fib(42); // 编译期完成计算

// [捕获列表](参数列表) mutable? exception? -> 返回类型 { 函数体 }
auto add = [](int a, int b) { return a + b; };
std::cout << add(3, 5); // 8

// C语言：通过函数指针实现回调
void (*callback)(int);
callback = &handle_event;

// C++：lambda直接捕获上下文
std::vector<int> data = {1,2,3};
std::for_each(data.begin(), data.end(), [&](int x) {
    std::cout << x * data.size(); // 直接捕获data
});

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> vec = {1, 2, 3, 4, 5};

    // 使用Lambda表达式对vector中的元素进行排序（降序）
    sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b;
    });

    // 输出排序后的vector
    for (int n : vec) {
        cout << n << " ";
    }
    cout << endl;

    return 0;
}

template <typename T>
T max(T a, T b) { return a > b ? a : b; }

int main() {
    std::cout << max(5, 3);    // int
    std::cout << max(3.14, 2.71); // double
}

// 特化指针版本
template <typename T>
T* max(T* a, T* b) { return *a > *b ? a : b; }

// 特化字符串版本
template <>
const char* max(const char* a, const char* b) {
    return std::strcmp(a, b) > 0 ? a : b;
}

class Shape {
public:
    virtual double area() const = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    double area() const override { return M_PI * r * r; }
};

class Data {
private:
    int value;
public:
    int get() const { return value; } // 保证不修改成员
    void set(int v) { value = v; }
};

// 声明不抛异常（C++11）
void critical_operation() noexcept {
    // 若抛出异常，调用std::terminate()
}

// 有条件不抛异常
void safe_operation() noexcept(std::is_integral_v<Param>) {
    // 仅当Param为整数类型时不抛异常
}

// 传统写法（需前置声明）
template <typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

// C++14简化（自动推导）
template <typename T, typename U>
auto add(T t, U u) {
    return t + u;
}

// 返回指向成员函数的指针
auto get_fun() -> int (Data::*)() const {
    return &Data::get;
}

int base = 10;
auto adder = [a = base + 10](int x) { return a + x; };
std::cout << adder(5); // 25（a=20）

// C语言需手动封装状态
typedef struct { int base; } Adder;
int add(Adder* self, int x) { return self->base + x; }
Adder adder = { .base = 20 };
add(&adder, 5); // 25（需显式传递状态）

class Data {
    friend void print(const Data& d); // 友元声明
private:
    int value;
};

void print(const Data& d) { // 访问私有成员
    std::cout << "Value: " << d.value << '\n';
}

template <typename T>
class Container {
    friend T; // 授予整个类友元权限
    friend void debug(Container<T>& c); // 授予特定函数权限
};

class Data {
public:
    void print() const { std::cout << value << '\n'; }
    int value;
};

int main() {
    Data d{42};
    void (Data::*mem_fn)() const = &Data::print;
    (d.*mem_fn)(); // 42（调用成员函数）
}

#include <coroutine>

struct Generator {
    struct promise_type {
        int current_value = 0;
        Generator get_return_object() { return Generator{this}; }
        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }
        std::suspend_void return_void() { return {}; }
    };
    // ... 其他实现 ...
};

Generator countdown(int n) {
    for (; n >= 0; --n) co_yield n;
}

// 使用协同函数
for (int x : countdown(5)) {
    std::cout << x << ' '; // 5 4 3 2 1 0
}

// 优先匹配非模板函数
void print(int x) { /* 特化实现 */ }
template <typename T> void print(T x) { /* 通用实现 */ }

// 避免不必要的捕获
auto processor = [=](int x) mutable noexcept { /* 无堆分配的轻量级lambda */ };

class Resource {
public:
    void use() const noexcept { /* 无修改的常量成员 */ }
    ~Resource() = default; // 遵循Rule of Zero
};