linux c++例子

下面是一个简单的 Linux C++ 代码示例，它打印出“Hello, World!”：

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

要编译这个程序，可以使用 g++ 命令：

g++ -o hello hello.cpp

然后，运行可执行文件：

./hello

输出应该是：

Hello, World!

注意，编译和运行需要在 Linux 系统上进行。

相关问题

Linux C++ 线程

好的，我来为您简单介绍一下 Linux C++ 中的线程。

在 Linux 中，线程是通过 pthread 库来实现的。使用 pthread 库，需要在代码中包含头文件 `pthread.h`。

线程的创建需要调用 `pthread_create` 函数，该函数的参数包括线程标识符、线程属性、线程运行函数和运行函数的参数。例如：

#include <pthread.h>
#include <iostream>

void* thread_func(void* arg) {
    std::cout << "This is a new thread!" << std::endl;
    pthread_exit(NULL);
}

int main() {
    // 创建线程
    pthread_t thread_id;
    int ret = pthread_create(&thread_id, NULL, thread_func, NULL);
    if (ret != 0) {
        std::cerr << "pthread_create error: error_code = " << ret << std::endl;
        return ret;
    }

    // 等待线程结束
    pthread_join(thread_id, NULL);

    return 0;
}

在上面的例子中，`thread_func` 函数是新线程要执行的函数，通过 `pthread_create` 创建新线程并传入 `thread_func` 函数，`pthread_join` 则是等待新线程结束。

线程的同步可以使用互斥锁和条件变量来实现。互斥锁用于保护共享资源的访问，条件变量则用于线程间的通信。例如：

#include <pthread.h>
#include <iostream>
#include <queue>

std::queue<int> g_queue;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;

void* producer(void* arg) {
    for (int i = 0; i < 10; ++i) {
        pthread_mutex_lock(&g_mutex);
        g_queue.push(i);
        std::cout << "produce " << i << std::endl;
        pthread_mutex_unlock(&g_mutex);
        pthread_cond_signal(&g_cond);
    }
    pthread_exit(NULL);
}

void* consumer(void* arg) {
    while (true) {
        pthread_mutex_lock(&g_mutex);
        while (g_queue.empty()) {
            pthread_cond_wait(&g_cond, &g_mutex);
        }
        int value = g_queue.front();
        g_queue.pop();
        pthread_mutex_unlock(&g_mutex);
        std::cout << "consume " << value << std::endl;
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t producer_id, consumer_id;
    pthread_create(&producer_id, NULL, producer, NULL);
    pthread_create(&consumer_id, NULL, consumer, NULL);

    pthread_join(producer_id, NULL);
    pthread_join(consumer_id, NULL);

    return 0;
}

在上面的例子中，`producer` 线程不断往队列中添加数据，`consumer` 线程则不断从队列中取出数据消费。当队列为空时，`consumer` 线程会调用 `pthread_cond_wait` 函数等待生产者线程往队列中添加数据，并且在调用 `pthread_cond_wait` 函数前需要先释放互斥锁，以便其他线程可以访问共享资源。当有数据被添加到队列后，生产者线程会调用 `pthread_cond_signal` 函数通知消费者线程，消费者线程被唤醒后再次获取互斥锁并消费队列中的数据。

以上是 Linux C++ 中线程的简单介绍，希望对您有所帮助。

linux C++ memcpy

在 Linux C++ 中，`memcpy` 函数是用来执行内存拷贝的标准函数，其原型定义在头文件 `string.h` 中，函数的定义如下：

void* memcpy(void* dest, const void* src, size_t n);

其中，`dest` 是指向目标内存位置的指针，`src` 是指向源内存位置的指针，`n` 是要拷贝的字节数。`memcpy` 函数会将 `src` 指向的内存区域的前 `n` 个字节拷贝到 `dest` 指向的内存区域。如果 `src` 和 `dest` 指向的内存区域重叠，那么 `memcpy` 函数的行为是未定义的。

下面是一个使用 `memcpy` 函数将一个字符串拷贝到另一个字符串的例子：

#include <iostream>
#include <cstring>

int main()
{
    char src[] = "Hello, world!";
    char dest[20];

    std::memcpy(dest, src, std::strlen(src) + 1);

    std::cout << dest << std::endl;

    return 0;
}

在这个例子中，我们将字符串 `"Hello, world!"` 拷贝到了 `dest` 数组中，并使用 `std::strlen` 函数计算了源字符串的长度。注意，为了在 `dest` 数组中存储完整的源字符串，我们需要在拷贝时加上一个字节用于存储字符串结束符 `\0`。