1
#include <memory>
2
#include <iostream>
3

4
int main() {
5
    // 创建 shared_ptr 的几种方式
6
    std::shared_ptr<int> ptr1(new int(42));          // 直接初始化
7
    std::shared_ptr<int> ptr2 = std::make_shared<int>(42);  // 推荐方式，更高效
8
    auto ptr3 = std::make_shared<int>(42);           // 使用 auto 关键字
9

10
    // 访问指针内容
11
    std::cout << "Value: " << *ptr1 << std::endl;    // 解引用
12
    std::cout << "Address: " << ptr1.get() << std::endl; // 获取裸指针
13

14
    // 检查是否唯一所有者
15
    std::cout << "Use count: " << ptr1.use_count() << std::endl;
16
    std::cout << "Unique: " << ptr1.unique() << std::endl;
17

18
    return 0;
19
}

1
#include <memory>
2
#include <iostream>
3

4
void demonstrate_reference_counting() {
5
    auto ptr1 = std::make_shared<int>(100);
6
    std::cout << "After ptr1 creation - use_count: " << ptr1.use_count() << std::endl; // 1
7

8
    {
9
        auto ptr2 = ptr1;  // 拷贝构造，引用计数+1
10
        std::cout << "After ptr2 creation - use_count: " << ptr1.use_count() << std::endl; // 2
11

12
        auto ptr3 = ptr1;  // 引用计数再+1
13
        std::cout << "After ptr3 creation - use_count: " << ptr1.use_count() << std::endl; // 3
14
    }  // ptr2 和 ptr3 离开作用域被销毁，引用计数-2
15

16
    std::cout << "After ptr2, ptr3 destroyed - use_count: " << ptr1.use_count() << std::endl; // 1
17

18
    ptr1.reset();  // 手动释放，引用计数归零，内存被释放
19
    std::cout << "After reset - use_count: " << ptr1.use_count() << std::endl; // 0
20
}

1
#include <memory>
2
#include <iostream>
3

4
// 自定义删除器示例
5
struct FileDeleter {
6
    void operator()(FILE* file) {
7
        if (file) {
8
            fclose(file);
9
            std::cout << "File closed successfully" << std::endl;
10
        }
11
    }
12
};
13

14
void custom_deleter_example() {
15
    // 使用自定义删除器管理文件资源
16
    std::shared_ptr<FILE> file_ptr(fopen("test.txt", "w"), FileDeleter());
17
    if (file_ptr) {
18
        fputs("Hello, World!", file_ptr.get());
19
    }
20
    // 文件会在 shared_ptr 销毁时自动关闭
21
}
22

23
// Lambda 表达式作为删除器
24
void lambda_deleter_example() {
25
    auto array_deleter = [](int* arr) {
26
        delete[] arr;
27
        std::cout << "Array deleted" << std::endl;
28
    };
29

30
    std::shared_ptr<int> arr_ptr(new int[10], array_deleter);
31
}

1
#include <memory>
2
#include <iostream>
3

4
struct Node {
5
    std::string name;
6
    std::shared_ptr<Node> next;
7
    std::weak_ptr<Node> prev;  // 使用 weak_ptr 避免循环引用
8

9
    Node(const std::string& n) : name(n) {
10
        std::cout << "Node " << name << " created" << std::endl;
11
    }
12

13
    ~Node() {
14
        std::cout << "Node " << name << " destroyed" << std::endl;
15
    }
16
};
17

18
void circular_reference_example() {
19
    auto node1 = std::make_shared<Node>("A");
20
    auto node2 = std::make_shared<Node>("B");
21

22
    node1->next = node2;
23
    node2->prev = node1;  // 使用 weak_ptr，不会增加引用计数
24

25
    std::cout << "node1 use_count: " << node1.use_count() << std::endl; // 1
26
    std::cout << "node2 use_count: " << node2.use_count() << std::endl; // 2
27
}

1
// Tcp Server:
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5
#include <unistd.h>
6
#include <sys/socket.h>
7
#include <netinet/in.h>
8
#include <arpa/inet.h>
9
#include <signal.h>
10
#include <errno.h>
11

12
#define PORT 8080               // 服务器端口号（非特权端口，1024-65535）
13
#define BACKLOG 10              // 最大等待连接队列长度
14
#define BUFFER_SIZE 1024        // 数据缓冲区大小
15
#define MAX_CLIENTS 100         // 最大客户端数量
16

17
// 全局变量，用于信号处理
18
static volatile int keep_running = 1;
19

20
// 信号处理函数
21
void signal_handler(int sig) {
22
    keep_running = 0;
23
    printf("\nReceived signal %d, shutting down...\n", sig);
24
}
25

26
int main() {
27
    int server_fd, new_socket;
28
    struct sockaddr_in address;
29
    int addrlen = sizeof(address);
30
    char buffer[BUFFER_SIZE] = {0};
31

32
    // 设置信号处理
33
    signal(SIGINT, signal_handler);
34
    signal(SIGTERM, signal_handler);
35

36
    // 1. 创建 TCP 套接字
37
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
38
        perror("socket failed");
39
        exit(EXIT_FAILURE);
40
    }
41

42
    // 设置 SO_REUSEADDR 选项，避免 TIME_WAIT 状态导致绑定失败
43
    int opt = 1;
44
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
45
        perror("setsockopt failed");
46
        close(server_fd);
47
        exit(EXIT_FAILURE);
48
    }
49

50
    // 2. 设置服务器地址结构
51
    address.sin_family = AF_INET;
52
    address.sin_addr.s_addr = INADDR_ANY;
53
    address.sin_port = htons(PORT);
54

55
    // 3. 绑定套接字
56
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
57
        perror("bind failed");
58
        close(server_fd);
59
        exit(EXIT_FAILURE);
60
    }
61

62
    // 4. 开始监听
63
    if (listen(server_fd, BACKLOG) < 0) {
64
        perror("listen failed");
65
        close(server_fd);
66
        exit(EXIT_FAILURE);
67
    }
68

69
    printf("TCP Server started successfully, listening on port: %d\n", PORT);
70
    printf("Press Ctrl+C to stop the server\n");
71

72
    // 5. 主服务器循环
73
    while (keep_running) {
74
        // 使用 select 实现非阻塞检查，避免永久阻塞在 accept
75
        fd_set read_fds;
76
        FD_ZERO(&read_fds);
77
        FD_SET(server_fd, &read_fds);
78

79
        struct timeval timeout;
80
        timeout.tv_sec = 1;  // 1秒超时
81
        timeout.tv_usec = 0;
82

83
        int activity = select(server_fd + 1, &read_fds, NULL, NULL, &timeout);
84

85
        if (activity < 0 && errno != EINTR) {
86
            perror("select error");
87
            break;
88
        }
89

90
        if (!keep_running) {
91
            break;  // 收到停止信号
92
        }
93

94
        if (activity > 0 && FD_ISSET(server_fd, &read_fds)) {
95
            // 接受新连接
96
            if ((new_socket = accept(server_fd, (struct sockaddr *)&address,
97
                                   (socklen_t*)&addrlen)) < 0) {
98
                perror("accept failed");
99
                continue;
100
            }
101

102
            // 打印客户端信息
103
            printf("New client connected: %s:%d\n",
104
                   inet_ntoa(address.sin_addr),
105
                   ntohs(address.sin_port));
106

107
            // 处理客户端请求
108
            handle_client(new_socket, &address);
109
        }
110
    }
111

112
    // 清理资源
113
    printf("Server shutdown complete\n");
114
    close(server_fd);
115
    return 0;
116
}
117

118
// 客户端处理函数
119
void handle_client(int client_socket, struct sockaddr_in* client_addr) {
120
    char buffer[BUFFER_SIZE];
121
    char client_ip[INET_ADDRSTRLEN];
122

123
    inet_ntop(AF_INET, &(client_addr->sin_addr), client_ip, INET_ADDRSTRLEN);
124
    int client_port = ntohs(client_addr->sin_port);
125

126
    while (1) {
127
        memset(buffer, 0, BUFFER_SIZE);
128
        ssize_t bytes_read = read(client_socket, buffer, BUFFER_SIZE - 1);
129

130
        if (bytes_read < 0) {
131
            perror("read failed");
132
            break;
133
        } else if (bytes_read == 0) {
134
            printf("Client %s:%d disconnected\n", client_ip, client_port);
135
            break;
136
        }
137

138
        // 处理接收到的数据
139
        buffer[bytes_read] = '\0';
140
        printf("Received from %s:%d: %s\n", client_ip, client_port, buffer);
141

142
        // 简单的回声服务器逻辑
143
        std::string response = "Echo: " + std::string(buffer);
144
        if (send(client_socket, response.c_str(), response.length(), 0) < 0) {
145
            perror("send failed");
146
            break;
147
        }
148

149
        // 检查退出命令
150
        if (strncmp(buffer, "quit", 4) == 0) {
151
            printf("Client %s:%d requested disconnect\n", client_ip, client_port);
152
            break;
153
        }
154
    }
155

156
    close(client_socket);
157
}

1
// TCP Client implementation
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5
#include <unistd.h>
6
#include <sys/socket.h>
7
#include <netinet/in.h>
8
#include <arpa/inet.h>
9
#include <iostream>
10
#include <string>
11

12
#define SERVER_IP "127.0.0.1"
13
#define SERVER_PORT 8080
14
#define BUFFER_SIZE 1024
15

16
class TCPClient {
17
private:
18
    int sockfd;
19
    struct sockaddr_in server_addr;
20

21
public:
22
    TCPClient() : sockfd(-1) {
23
        memset(&server_addr, 0, sizeof(server_addr));
24
    }
25

26
    bool connectToServer(const std::string& ip, int port) {
27
        // 创建套接字
28
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
29
            perror("Socket creation failed");
30
            return false;
31
        }
32

33
        // 设置服务器地址
34
        server_addr.sin_family = AF_INET;
35
        server_addr.sin_port = htons(port);
36

37
        if (inet_pton(AF_INET, ip.c_str(), &server_addr.sin_addr) <= 0) {
38
            perror("Invalid address");
39
            close(sockfd);
40
            return false;
41
        }
42

43
        // 连接服务器
44
        if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
45
            perror("Connection failed");
46
            close(sockfd);
47
            return false;
48
        }
49

50
        std::cout << "Connected to server " << ip << ":" << port << std::endl;
51
        return true;
52
    }
53

54
    void sendMessage(const std::string& message) {
55
        if (send(sockfd, message.c_str(), message.length(), 0) < 0) {
56
            perror("Send failed");
57
            return;
58
        }
59

60
        std::cout << "Sent: " << message << std::endl;
61

62
        // 接收响应
63
        char buffer[BUFFER_SIZE] = {0};
64
        ssize_t bytes_received = read(sockfd, buffer, BUFFER_SIZE - 1);
65
        if (bytes_received > 0) {
66
            buffer[bytes_received] = '\0';
67
            std::cout << "Received: " << buffer << std::endl;
68
        }
69
    }
70

71
    void disconnect() {
72
        if (sockfd >= 0) {
73
            close(sockfd);
74
            sockfd = -1;
75
            std::cout << "Disconnected from server" << std::endl;
76
        }
77
    }
78

79
    ~TCPClient() {
80
        disconnect();
81
    }
82
};
83

84
// 使用示例
85
int main() {
86
    TCPClient client;
87

88
    if (client.connectToServer(SERVER_IP, SERVER_PORT)) {
89
        client.sendMessage("Hello, Server!");
90
        client.sendMessage("How are you?");
91
        client.sendMessage("quit");  // 退出命令
92
    }
93

94
    return 0;
95
}

1
编译 → 链接 → 加载 → 运行时初始化 → main → 清理退出

1
#include <coroutine>
2
#include <iostream>
3
#include <memory>
4
#include <thread>
5
#include <chrono>
6
#include <vector>
7

8
// 1. 简单的任务协程
9
struct SimpleTask {
10
    struct promise_type {
11
        SimpleTask get_return_object() {
12
            return SimpleTask{
13
                std::coroutine_handle<promise_type>::from_promise(*this)
14
            };
15
        }
16
        std::suspend_never initial_suspend() { return {}; }
17
        std::suspend_never final_suspend() noexcept { return {}; }
18
        void return_void() {}
19
        void unhandled_exception() { std::terminate(); }
20
    };
21

22
    std::coroutine_handle<promise_type> handle;
23

24
    explicit SimpleTask(std::coroutine_handle<promise_type> h) : handle(h) {}
25
    ~SimpleTask() {
26
        if (handle) handle.destroy();
27
    }
28

29
    void resume() {
30
        if (handle && !handle.done()) handle.resume();
31
    }
32
    bool done() const {
33
        return handle.done();
34
    }
35
};
36

37
// 2. 带值的任务协程
38
template<typename T>
39
struct ValueTask {
40
    struct promise_type {
41
        T value;
42

43
        ValueTask get_return_object() {
44
            return ValueTask{
45
                std::coroutine_handle<promise_type>::from_promise(*this)
46
            };
47
        }
48
        std::suspend_never initial_suspend() { return {}; }
49
        std::suspend_always final_suspend() noexcept { return {}; }
50
        void return_value(T val) { value = std::move(val); }
51
        void unhandled_exception() { std::terminate(); }
52

53
        // 支持 co_yield
54
        std::suspend_always yield_value(T val) {
55
            value = std::move(val);
56
            return {};
57
        }
58
    };
59

60
    std::coroutine_handle<promise_type> handle;
61

62
    explicit ValueTask(std::coroutine_handle<promise_type> h) : handle(h) {}
63
    ~ValueTask() { if (handle) handle.destroy(); }
64

65
    T get_value() const { return handle.promise().value; }
66
    void resume() { if (!handle.done()) handle.resume(); }
67
    bool done() const { return handle.done(); }
68
};
69

70
// 3. 异步操作等待器
71
struct AsyncOperation {
72
    bool completed{false};
73
    std::function<void()> completion_handler;
74

75
    bool await_ready() const {
76
        return completed;
77
    }
78

79
    void await_suspend(std::coroutine_handle<> handle) {
80
        // 模拟异步操作
81
        std::thread([this, handle]() mutable {
82
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
83
            completed = true;
84
            if (completion_handler) completion_handler();
85
            handle.resume(); // 恢复协程
86
        }).detach();
87
    }
88

89
    void await_resume() {
90
        std::cout << "Async operation completed!" << std::endl;
91
    }
92
};
93

94
// 4. 高级生成器实现
95
template<typename T>
96
class Generator {
97
public:
98
    struct promise_type {
99
        T current_value;
100
        std::exception_ptr exception;
101

102
        Generator get_return_object() {
103
            return Generator{
104
                std::coroutine_handle<promise_type>::from_promise(*this)
105
            };
106
        }
107

108
        std::suspend_always initial_suspend() { return {}; }
109
        std::suspend_always final_suspend() noexcept { return {}; }
110

111
        std::suspend_always yield_value(T value) {
112
            current_value = std::move(value);
113
            return {};
114
        }
115

116
        void return_void() {}
117
        void unhandled_exception() {
118
            exception = std::current_exception();
119
        }
120
    };
121

122
    using handle_type = std::coroutine_handle<promise_type>;
123

124
    explicit Generator(handle_type h) : coro(h) {}
125
    ~Generator() {
126
        if (coro) coro.destroy();
127
    }
128

129
    // 禁用拷贝
130
    Generator(const Generator&) = delete;
131
    Generator& operator=(const Generator&) = delete;
132

133
    // 允许移动
134
    Generator(Generator&& other) noexcept : coro(other.coro) {
135
        other.coro = {};
136
    }
137

138
    Generator& operator=(Generator&& other) noexcept {
139
        if (this != &other) {
140
            if (coro) coro.destroy();
141
            coro = other.coro;
142
            other.coro = {};
143
        }
144
        return *this;
145
    }
146

147
    // 迭代器支持
148
    class iterator {
149
    public:
150
        explicit iterator(handle_type coro = {}) : coro(coro) {}
151

152
        iterator& operator++() {
153
            if (coro && !coro.done()) {
154
                coro.resume();
155
            }
156
            return *this;
157
        }
158

159
        bool operator==(const iterator& other) const {
160
            return coro == other.coro || (coro.done() && other.coro.done());
161
        }
162

163
        bool operator!=(const iterator& other) const {
164
            return !(*this == other);
165
        }
166

167
        const T& operator*() const {
168
            return coro.promise().current_value;
169
        }
170

171
        const T* operator->() const {
172
            return &coro.promise().current_value;
173
        }
174

175
    private:
176
        handle_type coro;
177
    };
178

179
    iterator begin() {
180
        if (coro && !coro.done()) {
181
            coro.resume();
182
        }
183
        return iterator{coro};
184
    }
185

186
    iterator end() {
187
        return iterator{};
188
    }
189

190
private:
191
    handle_type coro;
192
};

1
// 1. 生成器使用示例
2
Generator<int> fibonacci(int limit) {
3
    int a = 0, b = 1;
4
    for (int i = 0; i < limit; ++i) {
5
        co_yield a;
6
        std::tie(a, b) = std::make_pair(b, a + b);
7
    }
8
}
9

10
Generator<std::string> tokenize(const std::string& text, char delimiter) {
11
    size_t start = 0, end = 0;
12
    while ((end = text.find(delimiter, start)) != std::string::npos) {
13
        co_yield text.substr(start, end - start);
14
        start = end + 1;
15
    }
16
    co_yield text.substr(start);
17
}
18

19
// 2. 异步任务使用示例
20
ValueTask<int> async_multiply(int a, int b) {
21
    std::cout << "Starting async multiplication..." << std::endl;
22

23
    // 模拟异步操作
24
    co_await AsyncOperation{};
25

26
    int result = a * b;
27
    std::cout << "Multiplication completed: " << a << " * " << b << " = " << result << std::endl;
28

29
    co_return result;
30
}
31

32
SimpleTask run_async_operations() {
33
    std::cout << "Starting multiple async operations..." << std::endl;
34

35
    auto task1 = async_multiply(6, 7);
36
    auto task2 = async_multiply(8, 9);
37

38
    // 等待任务完成
39
    while (!task1.done() || !task2.done()) {
40
        if (!task1.done()) task1.resume();
41
        if (!task2.done()) task2.resume();
42
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
43
    }
44

45
    std::cout << "All operations completed!" << std::endl;
46
    std::cout << "Results: " << task1.get_value() << ", " << task2.get_value() << std::endl;
47
}
48

49
// 3. 网络I/O协程示例（概念性）
50
struct AsyncReadOperation {
51
    int socket_fd;
52
    char* buffer;
53
    size_t size;
54

55
    bool await_ready() { return false; }
56

57
    void await_suspend(std::coroutine_handle<> handle) {
58
        // 在实际实现中，这里会使用 epoll/kqueue/IOCP 等异步I/O机制
59
        std::thread([this, handle]() mutable {
60
            ssize_t bytes_read = read(socket_fd, buffer, size);
61
            if (bytes_read >= 0) {
62
                handle.resume();
63
            }
64
            // 错误处理...
65
        }).detach();
66
    }
67

68
    ssize_t await_resume() {
69
        // 返回实际读取的字节数
70
        return 0; // 简化实现
71
    }
72
};
73

74
// 主函数演示
75
int main() {
76
    std::cout << "=== Generator Examples ===" << std::endl;
77

78
    // 斐波那契数列生成器
79
    std::cout << "Fibonacci sequence: ";
80
    for (auto num : fibonacci(10)) {
81
        std::cout << num << " ";
82
    }
83
    std::cout << std::endl;
84

85
    // 字符串分割生成器
86
    std::cout << "Tokenized string: ";
87
    for (const auto& token : tokenize("hello,world,how,are,you", ',')) {
88
        std::cout << "[" << token << "] ";
89
    }
90
    std::cout << std::endl;
91

92
    std::cout << "\n=== Async Task Examples ===" << std::endl;
93
    run_async_operations();
94

95
    return 0;
96
}

1
// 1. 协程内存池
2
class CoroutineMemoryPool {
3
private:
4
    std::vector<std::unique_ptr<char[]>> memory_blocks;
5
    size_t block_size;
6

7
public:
8
    CoroutineMemoryPool(size_t size = 4096) : block_size(size) {}
9

10
    void* allocate(size_t size) {
11
        if (size <= block_size && !memory_blocks.empty()) {
12
            auto block = std::move(memory_blocks.back());
13
            memory_blocks.pop_back();
14
            return block.release();
15
        }
16
        return ::operator new(size);
17
    }
18

19
    void deallocate(void* ptr, size_t size) {
20
        if (size <= block_size) {
21
            memory_blocks.push_back(std::unique_ptr<char[]>(static_cast<char*>(ptr)));
22
        } else {
23
            ::operator delete(ptr);
24
        }
25
    }
26
};
27

28
// 2. 自定义协程内存分配器
29
template<typename Promise>
30
struct custom_coroutine_traits {
31
    static CoroutineMemoryPool pool;
32

33
    static void* operator new(size_t size) {
34
        return pool.allocate(size);
35
    }
36

37
    static void operator delete(void* ptr, size_t size) {
38
        pool.deallocate(ptr, size);
39
    }
40
};
41

42
// 3. 批量协程调度
43
class CoroutineScheduler {
44
private:
45
    std::vector<std::coroutine_handle<>> ready_coroutines;
46
    std::vector<std::coroutine_handle<>> suspended_coroutines;
47

48
public:
49
    void schedule(std::coroutine_handle<> coro) {
50
        ready_coroutines.push_back(coro);
51
    }
52

53
    void run_batch(size_t max_executions = 1000) {
54
        for (size_t i = 0; i < max_executions && !ready_coroutines.empty(); ++i) {
55
            auto coro = ready_coroutines.back();
56
            ready_coroutines.pop_back();
57

58
            if (!coro.done()) {
59
                coro.resume();
60
                if (!coro.done()) {
61
                    suspended_coroutines.push_back(coro);
62
                }
63
            }
64
        }
65

66
        // 交换准备就绪的协程
67
        std::swap(ready_coroutines, suspended_coroutines);
68
        suspended_coroutines.clear();
69
    }
70
};

1
// 错误示例：悬空引用
2
Generator<int&> bad_generator() {
3
    int value = 42;
4
    co_yield value;  // 错误：返回局部变量的引用
5
} // value 被销毁，引用悬空
6

7
// 正确做法：返回值或使用智能指针
8
Generator<std::unique_ptr<int>> good_generator() {
9
    auto value = std::make_unique<int>(42);
10
    co_yield std::move(value);
11
}
12

13
// 错误示例：忘记检查协程状态
14
void unsafe_coroutine_use() {
15
    auto coro = some_coroutine();
16
    coro.resume();
17
    // 可能访问已销毁的协程
18
}
19

20
// 正确做法：使用 RAII 和状态检查
21
class SafeCoroutineWrapper {
22
    std::coroutine_handle<> handle;
23
    bool valid{false};
24

25
public:
26
    template<typename Coroutine>
27
    SafeCoroutineWrapper(Coroutine&& coro) : handle(coro.handle), valid(true) {}
28

29
    ~SafeCoroutineWrapper() {
30
        if (valid && handle) {
31
            handle.destroy();
32
        }
33
    }
34

35
    bool resume() {
36
        if (valid && handle && !handle.done()) {
37
            handle.resume();
38
            return true;
39
        }
40
        return false;
41
    }
42

43
    // 禁用拷贝，允许移动
44
    SafeCoroutineWrapper(const SafeCoroutineWrapper&) = delete;
45
    SafeCoroutineWrapper& operator=(const SafeCoroutineWrapper&) = delete;
46
    SafeCoroutineWrapper(SafeCoroutineWrapper&& other) noexcept
47
        : handle(other.handle), valid(other.valid) {
48
        other.valid = false;
49
    }
50
};