个人C++复习（3）

想不到好名字了（）2024-11-18 13:39

什么是回调函数，为什么需要回调函数

回调函数是一种通过函数指针或者函数对象（例如 std::function 或 lambda 表达式）将一个函数作为参数传递给另一个函数的机制。

实际上，就是把函数的调用权从一个地方转移到另一个地方，这个调用会在未来某个时刻进行，而不是立即执行。之所以称为"回调"，可以理解为某种倒叙执行：先安排好函数的调用，不立即执行，等到合适的时机再"回头"执行。

需要回调函数的主要原因包括：

  1. 异步编程：在异步操作中，比如网络请求、文件读取、事件处理等，可以在操作完成后调用回调函数，而主程序可以继续执行其它任务，避免等待操作完成。

  2. 解耦代码：回调函数有助于将代码模块化和解耦，允许我们创建更灵活和可复用的代码。例如，一个通用的排序算法可以接受一个比较函数，允许用户自定义排序逻辑。

  3. 事件驱动编程：在 GUI 或者其他事件驱动程序中，回调函数经常用于处理用户输入事件，如点击、鼠标移动、键盘输入等。

回调函数的实际应用

1.使用函数指针作为回调函数：

在C风格的接口中，最常见的回调函数的形式就是使用函数指针:

cpp 复制代码 
#include <iostream>

// 定义一个函数指针类型
typedef void (*CallbackFunc)(int);

void RegisterCallback(CallbackFunc cb) {
 // 模拟某些操作
 std::cout << "Registering callback...\n";
 cb(42); // 调用回调函数
}

void MyCallback(int value) {
 std::cout << "Callback called with value: " << value << std::endl;
}

int main() {
 RegisterCallback(MyCallback); // 传递回调函数
 return 0;
}

2.使用C++11之后的lambda表达式和std::function

cpp 复制代码 
#include <iostream>
#include <functional>

void RegisterCallback(std::function<void(int)> cb) {
 std::cout << "Registering callback...\n";
 cb(42); // 调用回调函数
}

int main() {
 auto myCallback = [](int value) {
     std::cout << "Callback called with value: " << value << std::endl;
 };
 RegisterCallback(myCallback); // 传递 lambda 回调函数
 return 0;
}

3.GUI编程中的回调

在图形用户界面的编程中，回调函数常用于处理用户事件。例如：在一个点击事件中调用用户提供的回调函数：

cpp 复制代码 
class Button {
 public:
 void setOnClick(std::function<void()> cb) {
     onClick = cb;
 }

 void simulateClick() {
     if (onClick) {
         onClick();
     }
 }

 private:
 std::function<void()> onClick;
};

int main() {
 Button button;
 button.setOnClick([]() {
     std::cout << "Button clicked!" << std::endl;
 });
 button.simulateClick(); // 模拟一次点击事件
 return 0;
}

C++中为什么要使用nullptr而不是NULL

主要原因是nullptr具有具体的类型，它是std::nullptr_t类型，可以避免代码中的不一致问题。还有一些原因：

1. 类型安全性（主要原因）

  • nullptr 是一个类型安全的指针常量 ：nullptr 是一个新的关键字，表示空指针，并且其类型为 std::nullptr_t。这意味着它可以被隐式转换为任何类型的指针，但不会被隐式转换为整数类型，从而避免了潜在的错误。

  • NULL 是一个宏 ：在C++中，NULL 通常定义为 0 或 (void*)0，这取决于实现。在某些情况下，将 NULL 用于指针和整数可能导致模糊性。例如，NULL 可以被解释为整数 0，这可能导致类型不明确的问题。

2. 可读性

  • 更清晰的语义 ：nullptr 明确表示它是一个空指针，而 NULL 作为一个宏，可能在上下文中引入混淆。使用 nullptr 可以提高代码的可读性，使意图更加明确。

3. 兼容性

  • 与 C++11 及以后的标准兼容 ：nullptr 是 C++11 引入的特性，符合现代 C++ 的编程风格。使用 nullptr 可以确保代码与 C++11 及以后的标准兼容。

4. 避免潜在的错误

  • 避免重载问题 ：在函数重载中，使用 NULL 可能会导致不明确的重载解析。例如，如果有多个重载函数，其中一个接受整数，另一个接受指针，传递 NULL 可能导致编译器无法确定应该调用哪个版本。使用 nullptr 可以消除这种模糊性，因为它明确表示指针类型。

例子

以下是一个例子，展示了使用 nullptr 和 NULL 的区别：

cpp 复制代码 
#include <iostream>

void func(int) {
    std::cout << "Called func(int)\n";
}

void func(char*) {
    std::cout << "Called func(char*)\n";
}

int main() {
    func(NULL);   // 可能会调用 func(int)，但不明确
    func(nullptr); // 明确调用 func(char*)
    return 0;
}

什么是大端序？什么是小端序

通俗点讲就是数据在内存中的存放顺序。

  1. 大端序：高字节存储在内存的低地址处，低字节存储在高地址处。例如，对于16进制数0x12345678，大端序在内存中的存储方式是：12 34 56 78。

  2. 小端序：低字节存储在内存的低地址处，高字节存储在高地址处。对于同样的16进制数0x12345678，小端序在内存中的存储方式是：78 56 34 12。

扩展知识

不同类型的计算机系统可能采取不同的字节序。比如，大多数的x86架构计算机采用小端序，而一些网络协议则规定采用大端序。

1）字节序的影响：字节序主要影响在多字节数据的存储与传输上。如果不同学节序的系统相互通信，需要注意字节序的转换，否则可能会读到错误的数据。

2）字节序的检测：可以通过如下方式进行检测：

cpp 复制代码 
#include <iostream>

bool isLittleEndian() {
    uint16_t num = 1;
    return *(reinterpret_cast<char*>(&num)) == 1;//将这个整型中的第一个字节提取出来，判断是否等于1，如果等于1那么就是低位放置在低地址处是小端，否则就是大端
}

int main() {
    if(isLittleEndian()) {
        std::cout << "System is Little-Endian" << std::endl;
    } else {
        std::cout << "System is Big-Endian" << std::endl;
    }
    return 0;
}

3）字节序的转换：有时候我们需要在大端和小端之间进行转换，C++提供了一些库函数，例如 htons() 和 htonl() 用于将主机字节序转换为网络字节序（一般是大端），ntohs() 和 ntohl() 用于将网络字节序转换为主机字节序。

最后只有整型才会区分大端序和小端序，浮点数是不进行区分的。

C++中的命名空间有什么作用

命名空间（namespace）主要用于解决名字冲突问题。当项目规模较大，包含很多函数、类、变量的时候，很容易出现名字相同的情况，这时候命名空间就显得特别重要。基本用法：

cpp 复制代码 
namespace MyNamespace {
    int myVar;
    void myFunc() {
        // do something
    }
}

扩展知识

如果不想在使用一个变量的时候都要加上命名空间的名字比如std::cout就可以使用using关键字

using namespace std之后就可以直接使用cout了

嵌套命名空间，可以在一个命名空间内部再定义一个命名空间，形成嵌套的形式：

cpp 复制代码 
namespace OuterNamespace {
 namespace InnerNamespace {
     int myVar;
     void myFunc() {
         // do something
     }
 }
}

访问的时候就要使用OuterNamespace::InnerNamespace::myVar这样去使用了。

匿名命名空间，如果我不想让某些名字在文件外部被访问到，就可以使用匿名命名空间。

cpp 复制代码 
namespace {
 int myVar;
 void myFunc() {
     // do something
 }
}

相当于给这些名字加上了static关键字，让其只能在这一个文件内部能够被访问。

标准命名空间C++标准库中的所有内容都储存在std标准库中。

C++中的友元类和友元函数的作用

  • 友元函数：是一个独立的函数，可以访问某个类的私有和保护成员。它通常用于需要访问类内部状态的场景，如操作符重载和提供接口。

  • 友元类：是一个类，允许一个类可以访问另一个类的私有和保护成员。它适用于两个类之间有复杂关系的场景。

友元类的例子：

cpp 复制代码 
class B; //前向声明

class A {
 private:
 int privateMember;

 public:
 A() : privateMember(0) {}
 //声明B为友元类
 friend class B;
};

class B {
 public:
 void accessA(A &obj) {
     //访问 A 的 privateMember
     obj.privateMember = 20;
 }
};

上面这个代码中的B类可以访问A类的私有或者保护成员，但是注意A类是无法访问B类的私有或者保护成员的。

扩展知识：

下面进一步讨论下它们的作用场景和设计考量：

1) 封装与开放：

  • 封装是面向对象编程的基本原则之一，它将数据和操作数据的方法绑定到一起，防止外部代码直接访问对象的内部状态。友元的引入让类在需要的时候能够部分地开放它的内部状态，通常不会滥用。
  • 友元函数和友元类提供了一种在不破坏封装性的条件下，安全访问私有成员的方式。

2) 友元的替代方案：

  • 如果友元机制的使用本质上意味着违反封装性或设计初衷，那么可能需要重新考量类的设计。
  • 你可以选择通过公开接口提供访问权限（如getter/setter方法），或利用继承、多态等其他面向对象编程（OOP）特性来实现同样的目的。

3) 访问控制复杂度：

  • 使用友元可能会增加代码的复杂度，因为它打破了类的封装性，代码的维护变得相对困难。所以，在维护代码时，需要非常小心，确保友元使用的合理性和必要性。

友元是一种方便但需要慎用的工具，合理使用能够简化代码，但滥用则会破坏类的封装性，增加代码维护的难度。建议在实际编程中能够权衡利弊，合理利用这一机制。

C++如何设计一个线程安全的类

如何设计一个线程安全的类？重点可以放在如何避免多线程环境下资源冲突的问题，可以从以下几个方面避免：

  1. 使用互斥锁（mutex）保护共享资源。
  2. 部分逻辑可以使用无锁编程，原子变量控制。
  3. 使用线程消息队列形式，保证此类里的所有操作任务在一个队列里，都在一个线程内调度，自然而然就解决了多线程问题。

要设计一个线程安全的类，通常情况下，我们会使用互斥锁（mutex）来保护共享资源，确保在任何时刻只有一个线程可以访问修改这些资源。

下面是一个简单示例，展示了如何使用 线程消息队列形式来实现一个线程安全的类：

cpp 复制代码 
#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <atomic>

class ThreadSafeQueue {
private:
    std::queue<std::function<void()>> tasks; // 存储任务的队列
    std::mutex mtx; // 互斥量
    std::condition_variable cv; // 条件变量
    std::atomic<bool> stop; // 停止标志

public:
    ThreadSafeQueue() : stop(false) {
        // 启动工作线程
        std::thread([this]() { this->worker(); }).detach();
    }

    ~ThreadSafeQueue() {
        stop = true; // 设置停止标志
        cv.notify_all(); // 唤醒工作线程
    }

    // 添加任务到队列
    void enqueue(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            tasks.push(task);
        }
        cv.notify_one(); // 通知工作线程有新任务
    }

private:
    // 工作线程执行任务
    void worker() {
        while (!stop) {
            std::function<void()> task;

            {
                std::unique_lock<std::mutex> lock(mtx);
                cv.wait(lock, [this] { return stop || !tasks.empty(); }); // 等待任务或停止信号

                if (stop && tasks.empty()) {
                    return; // 如果停止且队列为空，退出
                }

                task = std::move(tasks.front());
                tasks.pop();
            }

            // 执行任务
            task();
        }
    }
};

// 示例使用
class Example {
private:
    ThreadSafeQueue queue;

public:
    void doSomething(int value) {
        queue.enqueue([value]() {
            std::cout << "Processing value: " << value << " in thread: " << std::this_thread::get_id() << std::endl;
        });
    }
};

int main() {
    Example example;

    // 启动多个线程来添加任务
    std::thread t1([&]() { for (int i = 0; i < 5; ++i) example.doSomething(i); });
    std::thread t2([&]() { for (int i = 5; i < 10; ++i) example.doSomething(i); });

    t1.join();
    t2.join();

    // 让主线程稍等，确保所有任务完成
    std::this_thread::sleep_for(std::chrono::seconds(1));

    return 0;
}

在Example类中封装了一个任务队列，当外部使用另外的线程去执行Example类对象的方法时，会往任务队列中进行任务的添加，然后任务队列类，就会唤醒等待的线程去执行任务。这样也是一个线程安全的类。这里只是简单的进行了说明

代码说明

  1. ThreadSafeQueue 类：实现了一个线程安全的任务队列，包含添加任务和执行任务的逻辑。工作线程在后台运行并处理队列中的任务。

  2. enqueue 方法：用于将任务添加到队列，并通知工作线程。

  3. worker 方法：工作线程从队列中获取任务并执行，直到收到停止信号。

  4. Example 类 ：示例类，使用 ThreadSafeQueue 来处理任务。

  5. 主函数：启动多个线程来添加任务，并确保所有任务完成后退出。

总结

通过使用消息队列和工作线程的设计，可以有效地将所有操作调度到一个线程中执行，从而避免了多线程带来的复杂性和潜在问题。这种设计模式在许多应用中都非常有效，特别是在需要处理异步任务或事件的场景中。

扩展知识

1) 读写锁

有时我们需要实现的场景是多线程可以同时读数据，但写数据时需要独占锁。这可以使用 std::shared_mutex (C++17引入)来实现。std::shared_lock允许多个线程同时获取读锁，而std::unique_lock则用于写锁。

2) 原子操作

对于一些简单的整型操作，可以使用 std::atomic来代替互斥锁。std::atomic提供了高效的原子操作，避免了锁的开销。

cpp 复制代码 
#include <atomic>
class AtomicCounter {
public:
    AtomicCounter() : value(0) {}

    void increment() {
        value.fetch_add(1, std::memory_order_relaxed);
    }

    int getValue() {
        return value.load(std::memory_order_relaxed);
    }

private:
    std::atomic<int> value;
};

3）使用合适的同步机制 当多个线程需要协调工作时，可以使用条件变量来等待特定条件满足后再进行操作。

C++如何调用C语言的库

在C++中调用C语言的库是一个常见的需求，尤其是在需要利用已有的C语言代码或库时。C++与C语言具有很好的兼容性，但在调用C语言的库时需要注意一些细节。以下是调用C语言库的步骤和注意事项：

1. 确保C语言库的可用性

首先，确保你有一个可用的C语言库，通常以.c或.h文件形式存在，编译后生成的库文件通常以.a（静态库）或.so（动态库）为后缀。

2. 使用 extern "C" 进行声明

由于C++对函数名进行名称修饰（name mangling），而C语言不进行这种处理，因此在C++代码中引用C语言的函数时，需要使用extern "C"来告诉编译器使用C语言的链接方式。这样能够保证C语言中的函数能够被正确的调用。

3. 编写C语言库

假设你有一个简单的C语言库，包含以下内容：

example.c

cpp 复制代码 
#include <stdio.h>

void hello() {
    printf("Hello from C!\n");
}

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

example.h

cpp 复制代码 
#ifndef EXAMPLE_H
#define EXAMPLE_H

#ifdef __cplusplus
extern "C" {
#endif

void hello();
int add(int a, int b);

#ifdef __cplusplus
}
#endif

#endif // EXAMPLE_H

4. 编译C语言库

你可以使用以下命令编译C代码为共享库：

bash 复制代码 
gcc -c example.c -o example.o
gcc -shared -o libexample.so example.o

或者编译为静态库：

bash 复制代码 
gcc -c example.c -o example.o
ar rcs libexample.a example.o

5. 在C++代码中调用C库

接下来，你可以在C++代码中调用这个C语言库：

main.cc

cpp 复制代码 
#include <iostream>
#include "example.h" // 包含C语言库的头文件

int main() {
    hello(); // 调用C语言函数

    int result = add(3, 4); // 调用C语言的加法函数
    std::cout << "Result of add: " << result << std::endl;

    return 0;
}

注意事项

  1. 链接顺序：在链接时，C语言库的名称需要在C++源文件之后指定。

  2. C++与C的类型兼容性：确保在C++代码中使用的类型与C语言库中定义的类型兼容。

  3. 头文件保护 ：在C语言头文件中使用#ifdef __cplusplus来确保C++编译器能够正确处理C语言的函数声明。

  4. 编译器兼容性：确保使用的C和C++编译器能够互相兼容，通常使用GCC或Clang会比较顺利。

如果你的C库里有C++不支持的特性，比如变量长度数组（VLA），需要仔细考虑兼容性。
6. 如果C库包含了结构体，尤其是那些带有复杂数据类型或指针的结构体，要确保它们在C++中能够正确处理。

  1. 最好是C和C++不要混用，如果要混用，建议做一个封装层，对C做一层C++的封装，然后上层的业务代码还是统一使用C++。

C++中指针和引用的区别

指针和引用是C++中两种用于间接访问变量的机制，尽管它们有相似之处，但在语法、用法和特性上有显著的区别。以下是它们之间的主要区别：

1. 定义和语法

  • 指针 ：指针是一个变量，用于存储另一个变量的地址，使用*符号来声明。

  • 引用 ：引用是一个别名，用于给一个已有的变量起一个新的名字，使用&符号来声明。

2. 初始化

  • 指针：指针可以在声明时不初始化，并且可以在任何时候指向不同的地址。

  • 引用：引用必须在声明时初始化，并且一旦初始化后不能再改变引用的对象。

3. 空值

  • 指针 ：指针可以被赋值为nullptr（或NULL），表示它不指向任何有效的地址。

  • 引用 ：引用不能为nullptr，因为引用必须始终引用一个有效的对象。

4. 语法使用

  • 指针 ：使用指针时，通常需要使用*来解引用，访问指针指向的值。

  • 引用：使用引用时，可以像使用普通变量一样使用，不需要解引用操作符。

5. 重新赋值

  • 指针：指针可以在任何时候重新指向其他地址。

  • 引用：引用一旦绑定到一个变量，就不能再改变引用的对象。

6. 适用场景

  • 指针 ：适合用来动态内存管理（如使用new和delete），以及用于数据结构（如链表、树等）中的节点链接。

  • 引用：适合用于函数参数传递，避免复制开销，和返回值，能够返回一个对象的别名。

最后还有一个小点：

  1. sizeof指针得到的是本指针的大小，sizeof引用得到的是引用所指向变量的大小。

总结

指针和引用都是用于间接访问变量的工具，但它们在语法、特性和适用场景上有明显的区别。指针提供了更大的灵活性，但也带来了更高的复杂性和潜在的错误（如空指针解引用）。引用则提供了更简洁的语法和更安全的使用方式。根据具体需求选择使用指针或引用是C++编程中的一个重要决策。

希望这篇博肯能对阅读的您有所帮助，如果发现了错误欢迎指出。

相关推荐
阿华的代码王国4 分钟前
【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案
java·开发语言·springboot
阑梦清川15 分钟前
概率论之常见分布与matlab绘图
开发语言·matlab·概率论
机器视觉知识推荐、就业指导30 分钟前
C++设计模式：工厂方法模式
c++·设计模式·工厂方法模式
Atlasgorov32 分钟前
JAVA_单例模式
java·开发语言·单例模式
闫铁娃38 分钟前
【AtCoder】Beginner Contest 380-C.Move Segment
c语言·开发语言·数据结构·c++·算法·线性回归
无极程序员1 小时前
PHP 条件语句
android·开发语言·ide·php·android studio
kitesxian1 小时前
Leetcode160.相交链表
数据结构·c++·链表
罔闻_spider1 小时前
递归（二）---力扣22括号生成，力扣78求子集
开发语言·python
h汉堡1 小时前
C语言的内存函数
c语言·开发语言·c++·学习
彭彭不吃虫子1 小时前
【字符串】给定一个字符串 text 和字符串列表 words，返回 words 中每个单词在 text 中的位置（要求最终的位置从小到大进行排序）
开发语言·数据结构·python
热门推荐
01将 HuggingFace 模型转换为 GGUF 及使用 ollama 运行 —— 以 Qwen2-0.5B 为例02聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04RAG 实践- Ollama+RagFlow 部署本地知识库05玄机平台应急响应—webshell查杀06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07Unity中PICO实现 隔空取物 和 接触抓取物体08文件或文件夹名称中有空格如何批量去除09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10一文介绍回归和分类的本质区别 ！！