C++实现三个进程P1、P2、P3互斥使用一个包含N个单元的缓冲区。P1每次用produe()产生一个正整数并用put()送入缓冲区某一空单元中；P2每次用getodd()从该缓冲区中取出一个奇数并用countodd()统计奇数个数；P3每次用geteven()从该缓冲区中取出一个偶数并用counteven()统计偶数个数

这道题需要使用进程同步技术（如互斥锁、信号量等）来实现进程间的互斥和同步操作。下面是一个可能的解决方案：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;

const int N = 10; // 缓冲区大小
int buffer[N]; // 缓冲区
int in = 0, out = 0; // 生产者和消费者的指针
int odd_count = 0, even_count = 0; // 奇数和偶数的计数器
mutex mtx; // 互斥锁
condition_variable cv; // 条件变量

void produce(int x) {
    unique_lock<mutex> lock(mtx);
    cv.wait(lock, [](){ return in != out || odd_count + even_count < N; });
    buffer[in] = x;
    in = (in + 1) % N;
    cout << "P1 produce " << x << endl;
    cv.notify_all();
}

int getodd() {
    unique_lock<mutex> lock(mtx);
    cv.wait(lock, [](){ return in != out || odd_count + even_count > 0; });
    int x = buffer[out];
    out = (out + 1) % N;
    if (x % 2 == 1) {
        odd_count++;
        cout << "P2 get odd " << x << endl;
    }
    cv.notify_all();
    return x;
}

int geteven() {
    unique_lock<mutex> lock(mtx);
    cv.wait(lock, [](){ return in != out || odd_count + even_count > 0; });
    int x = buffer[out];
    out = (out + 1) % N;
    if (x % 2 == 0) {
        even_count++;
        cout << "P3 get even " << x << endl;
    }
    cv.notify_all();
    return x;
}

void countodd() {
    while (true) {
        int x = getodd();
        // 处理奇数
    }
}

void counteven() {
    while (true) {
        int x = geteven();
        // 处理偶数
    }
}

int main() {
    thread t1([](){
        for (int i = 1; i <= 100; i++) {
            produce(i);
        }
    });
    thread t2(countodd);
    thread t3(counteven);
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

上面的代码使用了互斥锁 `mtx` 和条件变量 `cv` 来实现进程间的同步和互斥操作：

- 生产者 `P1` 调用 `produce` 函数来生产一个正整数，并将其放入缓冲区中。在调用 `wait` 函数时，使用 lambda 表达式来判断缓冲区是否已满，如果已满则等待条件变量 `cv` 的通知。在生产完一个正整数后，调用 `notify_all` 函数来通知等待消费者 `P2` 和 `P3` 的线程。
- 消费者 `P2` 调用 `getodd` 函数来从缓冲区中取出一个奇数，并将其计入奇数计数器 `odd_count`。在调用 `wait` 函数时，使用 lambda 表达式来判断缓冲区是否为空，如果为空则等待条件变量 `cv` 的通知。在取出一个奇数后，调用 `notify_all` 函数来通知等待生产者 `P1` 和消费者 `P3` 的线程。
- 消费者 `P3` 调用 `geteven` 函数来从缓冲区中取出一个偶数，并将其计入偶数计数器 `even_count`。在调用 `wait` 函数时，使用 lambda 表达式来判断缓冲区是否为空，如果为空则等待条件变量 `cv` 的通知。在取出一个偶数后，调用 `notify_all` 函数来通知等待生产者 `P1` 和消费者 `P2` 的线程。
- 值得注意的是，由于 `wait` 函数可能因为虚假唤醒而返回，因此在调用 `wait` 函数时，需要使用 while 循环来判断条件是否满足。同时，在修改共享变量之前，也需要先获取互斥锁 `mtx`，以避免多个线程同时修改共享变量而导致数据错误的问题。

在上面的代码中，我们使用了 `thread` 类来创建多个线程，分别用于生产者和消费者的操作。在主函数中，我们使用 `join` 函数来等待所有线程结束。