【C++】编程规范之函数规则

1. 对所有函数入参进行合法性检查
   在编写函数时，应该始终对所有传入的参数进行合法性检查，以防止出现意外的错误或异常情况。这包括但不限于检查指针是否为空、整数是否在有效范围内、数组是否越界等等。通过对参数进行严格的合法性检查，可以避免许多潜在的错误。

#include <iostream>

void divide(int dividend, int divisor) {
    if (divisor == 0) {
        std::cerr << "Error: divisor cannot be zero!" << std::endl;
        return;
    }
    int result = dividend / divisor;
    std::cout << "Result of division: " << result << std::endl;
}

int main() {
    divide(10, 2);    // 正常调用
    divide(10, 0);    // 非法调用，除数为0
    return 0;
}

2. 函数内部静态数组大小不超过1KB
   在函数内部使用静态数组时，应该确保数组的大小不超过1KB。这是为了避免在Android线程栈空间（通常小于1MB）中消耗过多的内存资源，从而导致栈溢出或者影响其他线程的正常运行。

#include <iostream>

void processArray() {
    static int arr[256];  // 256 * sizeof(int) = 1024 bytes
    // 对数组进行处理...
    std::cout << "Array processed successfully!" << std::endl;
}

int main() {
    processArray();
    return 0;
}

3. 函数不可返回指向栈内存的指针或引用
   在函数中返回指向栈内存的指针或引用是一种常见的错误做法，因为栈内存的生命周期与函数调用的生命周期相关联，一旦函数返回后，栈内存将被释放，导致指针或引用失效。为了避免这种情况，应该始终避免返回指向栈内存的指针或引用。

#include <iostream>

int* createArray() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    return arr;  // 错误：返回指向栈内存的指针
}

int main() {
    int* ptr = createArray();
    std::cout << "Value at index 0: " << ptr[0] << std::endl; // 未定义行为
    return 0;
}

4. 只读的指针形参需加const前缀
   在函数的参数列表中，如果某个指针形参只用于读取数据而不修改数据，应该在指针类型前加上const关键字，以确保该指针不会意外地修改数据。这有助于提高代码的可读性和安全性，并减少意外的错误。

#include <iostream>

void printArray(const int* arr, int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    printArray(arr, 5);
    return 0;
}

5. 函数返回的错误码需要进行处理
   在函数中可能会出现各种错误情况，例如参数错误、内存分配失败、文件操作失败等等。为了有效地处理这些错误情况，应该在函数中返回错误码，并在调用函数的地方进行适当的错误处理。这可以提高程序的稳定性和可靠性。

#include <iostream>

int divide(int dividend, int divisor) {
    if (divisor == 0) {
        return -1; // 返回错误码
    }
    return dividend / divisor;
}

int main() {
    int result = divide(10, 0);
    if (result == -1) {
        std::cerr << "Error: divisor cannot be zero!" << std::endl;
    } else {
        std::cout << "Result of division: " << result << std::endl;
    }
    return 0;
}

6. 线程安全
   在多线程环境中，函数的线程安全性尤为重要。为了确保函数的线程安全性，应该避免对全局变量和静态变量进行直接操作，而是使用线程安全的数据结构或加锁机制来保护共享数据的访问。通过采用适当的线程安全措施，可以避免多线程环境下的竞争条件和数据竞争，从而提高程序的并发性能和可靠性。

#include <iostream>
#include <mutex>

std::mutex mtx; // 全局互斥锁

void safeIncrement(int& num) {
    std::lock_guard<std::mutex> lock(mtx); // 使用互斥锁保护共享数据
    num++;
}

int main() {
    int count = 0;
    const int THREAD_COUNT = 5;

    std::vector<std::thread> threads;
    for (int i = 0; i < THREAD_COUNT; ++i) {
        threads.push_back(std::thread(safeIncrement, std::ref(count)));
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Final count value: " << count << std::endl;
    return 0;
}