为什么我不能调用我的结构信号量方法？

Question

我正在尝试输入小写字符并将其添加到 in.buffer，另一个线程应该从 in.buffer 读取并将其变为小写并发送到 out.buffer，最后一个应该阅读 out.buffer 并打印它。

我收到错误：在数字常量信号量之前需要标识符 m_free(10)；错误：无效使用成员函数‘Semaphore RingBuffer::m_free(int)’

这是为什么？

谢谢

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

struct Semaphore 
{
    Semaphore() = default;
    Semaphore(int x) : m_s(x) {}
    
    void release() {
        std::unique_lock<std::mutex> lock(m_mut);
        m_s += 1;
        m_cv.notify_one();
    }
    void acquire() {
        std::unique_lock<std::mutex> lock(m_mut);
        m_cv.wait(lock, [this](){ return m_s != 0; });
        m_s -= 1;
    }
    
    private:
    int m_s = 0;
    std::mutex m_mut;
    std::condition_variable m_cv;
};

struct RingBuffer {
    void write(char x);
    char read();
    
    private:
    std::array<char, 10> m_buff;
    int m_w = 0;
    int m_r = 0;
    Semaphore m_free(10);
    Semaphore m_taken(0);
    std::mutex m_mut;
};

void RingBuffer::write(char x) {
    m_free.acquire();
    {
        std::lock_guard<std::mutex> l(m_mut);
        m_buff[m_w] = x;
        m_w = m_w % 10 == 0 ? 0 : m_w + 1;
    }
    m_taken.release();
}
char RingBuffer::read() {
    int res=-1;
    m_taken.acquire();
    {
        std::lock_guard<std::mutex> l(m_mut);
        res = m_buff[m_r];
        m_r = m_r % 10 == 0 ? 0 : m_r + 1;
    }
    m_free.release();
    return res;
}

int main()
{
    //RING_SIZE;
    RingBuffer in,out;
    std::thread threadin([&in](){
        //while(true){
        char ch;
        std::cin>>ch;
        in.write(ch);
        
            
        //}
    });
    std::thread threaddo([&in,&out](){
        char ch=in.read();
         ch=ch-32;
         out.write(ch);
        //}
    });
    std::thread threadout([&out](){
        //while(true){
        char ch=out.read();
        std::cout<<ch<<std::endl;
        //}
    });
    
    threadin.join();
    threaddo.join();
    threadout.join();
    return 0;
}

Answer 1

您不能在 struct 中“调用”任何内容。 struct 包含其成员的定义，而不是代码。

您可以在 constructor:

中初始化一个成员

struct RingBuffer {
    Semaphore m_free;
    RingBuffer() : m_free(10) {} // constructor with a member-initializer-list
};

或内联使用 default member initializer:

struct RingBuffer {
    Semaphore m_free {10};
};

或

struct RingBuffer {
    Semaphore m_free = 10;
};

但是没有使用()初始化成员的语法。

为什么我不能调用我的结构信号量方法？

Why can't I call my struct Semaphore methods?

c++

multithreading

mutex

c++17