17个C++编程常见错误及其解决方案

int* ptr = nullptr;
std::cout << *ptr;  // 解引用空指针，可能导致段错误

if (ptr != nullptr) {
    std::cout << *ptr;
}

int shared_var = 0;

void thread_func() {
    for (int i = 0; i < 1000000; ++i) {
        shared_var++;  // 多线程并发执行此操作可能导致结果不准确
    }
}

int main() {
    std::thread t1(thread_func);
    std::thread t2(thread_func);
    t1.join();
    t2.join();
    std::cout << shared_var;  // 预期输出2000000，但实际上可能不是
}

std::mutex mtx;
int shared_var = 0;

void thread_func() {
    for (int i = 0; i < 1000000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        shared_var++;
    }
}

std::mutex m1, m2;
bool flag1 = false, flag2 = false;

void func1() {
    std::unique_lock<std::mutex> lck1(m1);
    std::unique_lock<std::mutex> lck2(m2, std::defer_lock);
    while (!flag2) {
        lck2.lock();  // 若func2已获得m1，这里将导致死锁
        // ...
    }
}

void func2() {
    std::unique_lock<std::mutex> lck2(m2);
    std::unique_lock<std::mutex> lck1(m1, std::defer_lock);
    while (!flag1) {
        lck1.lock();  // 若func1已获得m2，这里同样导致死锁
        // ...
    }
}

char str[10];
strcpy(str, "This is a very long string.");  // 可能造成缓冲区溢出

int* p = new int(5);
delete p;
*p = 10;  // 悬挂指针，可能导致段错误

void mayThrowException() {
    throw std::runtime_error("An error occurred.");
}

int main() {
    mayThrowException();  // 如果没有捕获，程序会终止
    return 0;
}

double a = 0.1;
double b = 0.2;
if (a + b == 0.3) {  // 这里可能为假，因为浮点数运算存在精度误差
    // ...
}

unsigned int a = 0;
unsigned int b = 1;
std::cout << a - b;  // 输出的结果将是UINT_MAX

long long num1 = LLONG_MAX;
int num2 = INT_MAX;
long long result = num1 + num2;  // num2提升为long long后导致溢出

std::ofstream file("output.txt");
file << "Some content";
// 忘记调用file.close()

unsigned int counter = 5;
while (counter >= 0) {  // 由于counter是无符号整数，当它递减至0时不会变为负数
    // 循环体执行
    --counter;
}  // 本应在counter为0时退出循环，但实际上会进入死循环

unsigned int limit = 5;
for (unsigned int counter = 0; counter < limit; ++counter) {
    // 循环体执行
}  // 当counter到达limit时，循环自然结束

double d = 3.14;
int i = d;  // 损失精度
if (d == 3) {  // 可能永远不成立，因为浮点数与整数比较会有精度损失
    // ...
}

for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    if (*it == target) {
        it = vec.erase(it);  // 直接删除当前元素可能导致未遍历完剩余元素
    }
}

char name[8] = "John Doe";  // 缺少终止符'\0'，可能会导致读取额外的内存数据

char name[9] = "John Doe";  // 确保有足够的空间存放'\0'
// 或者
std::string nameStr = "John Doe";  // 使用std::string类，无需手动管理终止符

int arr[5] = {1, 2, 3, 4, 5};
std::cout << arr[5];  // 数组越界，可能导致未定义行为

int arr[5] = {1, 2, 3, 4, 5};
int index = 5;
if (index >= 0 && index < sizeof(arr) / sizeof(arr[0])) {
    std::cout << arr[index];  // 正确进行边界检查
} else {
    std::cout << "Index out of bounds.\n";
}

void* memory = malloc(sizeof(int)*10);
free(memory);  // 在C++代码中混用了malloc和free

int* memory = new int[10];
delete[] memory;  // 使用delete[]释放动态分配的数组

std::unique_ptr<int[]> memory(new int[10]);  // 自动释放内存

int* singleMemory = new int;
delete singleMemory;  // 正确释放单个对象的内存

// cpp1
class Database {};  // 数据库类
Database globalDb;  // 全局数据库实例

// cpp2
class Service {
public:
    Service(Database& db) { std::cout << "Service initialized." << std::endl; }
};

Service globalService(globalDb);  // 依赖全局数据库的服务实例