个人C++复习（3）
什么是回调函数，为什么需要回调函数
回调函数是一种通过函数指针或者函数对象（例如 std::function 或 lambda 表达式）将一个函数作为参数传递给另一个函数的机制。
实际上，就是把函数的调用权从一个地方转移到另一个地方，这个调用会在未来某个时刻进行，而不是立即执行。之所以称为“回调”，可以理解为某种倒叙执行：先安排好函数的调用，不立即执行，等到合适的时机再“回头”执行。
需要回调函数的主要原因包括：
-
异步编程：在异步操作中，比如网络请求、文件读取、事件处理等，可以在操作完成后调用回调函数，而主程序可以继续执行其它任务，避免等待操作完成。
-
解耦代码：回调函数有助于将代码模块化和解耦，允许我们创建更灵活和可复用的代码。例如，一个通用的排序算法可以接受一个比较函数，允许用户自定义排序逻辑。
-
事件驱动编程：在 GUI 或者其他事件驱动程序中，回调函数经常用于处理用户输入事件，如点击、鼠标移动、键盘输入等。
回调函数的实际应用
1.使用函数指针作为回调函数：
在C风格的接口中，最常见的回调函数的形式就是使用函数指针:
#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
#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编程中的回调
在图形用户界面的编程中，回调函数常用于处理用户事件。例如：在一个点击事件中调用用户提供的回调函数：
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 的区别：
#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;
}
什么是大端序？什么是小端序
通俗点讲就是数据在内存中的存放顺序。
-
大端序：高字节存储在内存的低地址处，低字节存储在高地址处。例如，对于16进制数0x12345678，大端序在内存中的存储方式是：12 34 56 78。
-
小端序：低字节存储在内存的低地址处，高字节存储在高地址处。对于同样的16进制数0x12345678，小端序在内存中的存储方式是：78 56 34 12。
扩展知识
不同类型的计算机系统可能采取不同的字节序。比如，大多数的x86架构计算机采用小端序，而一些网络协议则规定采用大端序。
1）字节序的影响：字节序主要影响在多字节数据的存储与传输上。如果不同学节序的系统相互通信，需要注意字节序的转换，否则可能会读到错误的数据。
2）字节序的检测：可以通过如下方式进行检测：
#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）主要用于解决名字冲突问题。当项目规模较大，包含很多函数、类、变量的时候，很容易出现名字相同的情况，这时候命名空间就显得特别重要。基本用法：
namespace MyNamespace {
int myVar;
void myFunc() {
// do something
}
}
扩展知识
如果不想在使用一个变量的时候都要加上命名空间的名字比如std::cout就可以使用using关键字
using namespace std之后就可以直接使用cout了
嵌套命名空间，可以在一个命名空间内部再定义一个命名空间，形成嵌套的形式：
namespace OuterNamespace {
namespace InnerNamespace {
int myVar;
void myFunc() {
// do something
}
}
}
访问的时候就要使用OuterNamespace::InnerNamespace::myVar这样去使用了。
匿名命名空间，如果我不想让某些名字在文件外部被访问到，就可以使用匿名命名空间。
namespace {
int myVar;
void myFunc() {
// do something
}
}
相当于给这些名字加上了static关键字，让其只能在这一个文件内部能够被访问。
标准命名空间C++标准库中的所有内容都储存在std标准库中。
C++中的友元类和友元函数的作用
-
友元函数：是一个独立的函数，可以访问某个类的私有和保护成员。它通常用于需要访问类内部状态的场景，如操作符重载和提供接口。
-
友元类：是一个类，允许一个类可以访问另一个类的私有和保护成员。它适用于两个类之间有复杂关系的场景。
友元类的例子：
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++如何设计一个线程安全的类
如何设计一个线程安全的类？重点可以放在如何避免多线程环境下资源冲突的问题，可以从以下几个方面避免：
- 使用互斥锁（mutex）保护共享资源。
- 部分逻辑可以使用无锁编程，原子变量控制。
- 使用线程消息队列形式，保证此类里的所有操作任务在一个队列里，都在一个线程内调度，自然而然就解决了多线程问题。
要设计一个线程安全的类，通常情况下，我们会使用互斥锁（mutex）来保护共享资源，确保在任何时刻只有一个线程可以访问修改这些资源。
下面是一个简单示例，展示了如何使用 线程消息队列形式来实现一个线程安全的类：
#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类对象的方法时，会往任务队列中进行任务的添加，然后任务队列类，就会唤醒等待的线程去执行任务。这样也是一个线程安全的类。这里只是简单的进行了说明
代码说明
-
ThreadSafeQueue 类：实现了一个线程安全的任务队列，包含添加任务和执行任务的逻辑。工作线程在后台运行并处理队列中的任务。
-
enqueue 方法：用于将任务添加到队列，并通知工作线程。
-
worker 方法：工作线程从队列中获取任务并执行，直到收到停止信号。
-
Example 类：示例类，使用
ThreadSafeQueue来处理任务。 -
主函数：启动多个线程来添加任务，并确保所有任务完成后退出。
总结
通过使用消息队列和工作线程的设计，可以有效地将所有操作调度到一个线程中执行，从而避免了多线程带来的复杂性和潜在问题。这种设计模式在许多应用中都非常有效，特别是在需要处理异步任务或事件的场景中。
扩展知识
1) 读写锁
有时我们需要实现的场景是多线程可以同时读数据，但写数据时需要独占锁。这可以使用 std::shared_mutex (C++17引入)来实现。std::shared_lock允许多个线程同时获取读锁，而std::unique_lock则用于写锁。
2) 原子操作
对于一些简单的整型操作，可以使用 std::atomic来代替互斥锁。std::atomic提供了高效的原子操作，避免了锁的开销。
#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
#include <stdio.h>
void hello() {
printf("Hello from C!\n");
}
int add(int a, int b) {
return a + b;
}
example.h
#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代码为共享库：
gcc -c example.c -o example.o
gcc -shared -o libexample.so example.o
或者编译为静态库：
gcc -c example.c -o example.o
ar rcs libexample.a example.o
5. 在C++代码中调用C库
接下来，你可以在C++代码中调用这个C语言库：
main.cc
#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;
}
注意事项
-
链接顺序：在链接时，C语言库的名称需要在C++源文件之后指定。
-
C++与C的类型兼容性：确保在C++代码中使用的类型与C语言库中定义的类型兼容。
-
头文件保护：在C语言头文件中使用
#ifdef __cplusplus来确保C++编译器能够正确处理C语言的函数声明。 -
编译器兼容性：确保使用的C和C++编译器能够互相兼容，通常使用GCC或Clang会比较顺利。
-
如果你的C库里有C++不支持的特性，比如变量长度数组（VLA），需要仔细考虑兼容性。
-
如果C库包含了结构体，尤其是那些带有复杂数据类型或指针的结构体，要确保它们在C++中能够正确处理。
-
最好是C和C++不要混用，如果要混用，建议做一个封装层，对C做一层C++的封装，然后上层的业务代码还是统一使用C++。
C++中指针和引用的区别
指针和引用是C++中两种用于间接访问变量的机制，尽管它们有相似之处，但在语法、用法和特性上有显著的区别。以下是它们之间的主要区别：
1. 定义和语法
-
指针：指针是一个变量，用于存储另一个变量的地址，使用
*符号来声明。 -
引用：引用是一个别名，用于给一个已有的变量起一个新的名字，使用
&符号来声明。
2. 初始化
-
指针：指针可以在声明时不初始化，并且可以在任何时候指向不同的地址。
-
引用：引用必须在声明时初始化，并且一旦初始化后不能再改变引用的对象。
3. 空值
-
指针：指针可以被赋值为
nullptr（或NULL），表示它不指向任何有效的地址。 -
引用：引用不能为
nullptr，因为引用必须始终引用一个有效的对象。
4. 语法使用
-
指针：使用指针时，通常需要使用
*来解引用，访问指针指向的值。 -
引用：使用引用时，可以像使用普通变量一样使用，不需要解引用操作符。
5. 重新赋值
-
指针：指针可以在任何时候重新指向其他地址。
-
引用：引用一旦绑定到一个变量，就不能再改变引用的对象。
6. 适用场景
-
指针：适合用来动态内存管理（如使用
new和delete），以及用于数据结构（如链表、树等）中的节点链接。 -
引用：适合用于函数参数传递，避免复制开销，和返回值，能够返回一个对象的别名。
最后还有一个小点：
- sizeof指针得到的是本指针的大小，sizeof引用得到的是引用所指向变量的大小。
总结
指针和引用都是用于间接访问变量的工具，但它们在语法、特性和适用场景上有明显的区别。指针提供了更大的灵活性，但也带来了更高的复杂性和潜在的错误（如空指针解引用）。引用则提供了更简洁的语法和更安全的使用方式。根据具体需求选择使用指针或引用是C++编程中的一个重要决策。
希望这篇博肯能对阅读的您有所帮助，如果发现了错误欢迎指出。
原文地址：https://blog.csdn.net/D223546/article/details/143831692
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！