在int main（）中使用类函数

Question

我在从主程序调用函数时遇到问题。
这些功能必须在我的课堂上。
如何从int main（）访问它们？

#include <iostream>
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
#include <semaphore.h>
#include <synch.h>
using namespace std;   


class myCountingSemaphoreUsingBinarySemaphore {  
public:  
    void waitSemaphore(pthread_mutex_t *thread)  
    {  
        pthread_mutex_lock(*thread);// Makes value 1 (Not Available)  
    }  
    void signalSemaphore(pthread_mutex_t *thread)  
    {  
        pthread_mutex_unlock(*thread); // Makes value 0 (Available)  
    }  
    void deleteSemaphore(pthread_mutex_t *thread)   
    {  
        pthread_mutex_destroy(*thread);// Deletes  
    }  
};  
int readerCount;   
int database = (rand() / 100); // Number less than 1000  
void reader_writer(void);   
int main(int argc, char *argv[])  
{     
    myCountingSemaphoreUsingBinarySemaphore obj;  
    pthread_mutex_t mutex1;  
    pthread_mutex_t wrt;  
    pthread_create( &mutex1, NULL, reader_writer, void);  
    pthread_create( &wrt, NULL, reader_writer, void);  
    //----------------------READER------------------------//  
    do{  
        cout << "Database Before Read = " << database << endl;  
        obj.waitSemaphore(mutex1);//lock  
        readerCount++;  
        if (readerCount == 1)  
        {  
        obj.waitSemaphore(wrt);//lock  
        obj.signalSemaphore(mutex1);//unlock  
        //reading is preformed  
        obj.waitSemaphore(mutex1); // lock  
        readerCount--;  
        }  
        if(readerCount == 0)  
        {  
            obj.signalSemaphore(wrt);//unlock  
            obj.signalSemaphore(mutex1); // unlock  
        }  
        cout << "Database After Read = " << database << endl;  
    }while (true);  
    //-----------------------WRITER---------------------//  
    do{  
        cout << "Database Before Write = " << database << endl;  
        obj.waitSemaphore(wrt);//lock  
        //writing is preformed  
        database = database + 10;  
        obj.signalSemaphore(mutex1);//unlock  
        cout << "Database After Write = " << database << endl;  
    }while(true);  
    pthread_join( mutex1, NULL);  
    pthread_join( wrt, NULL);   
    obj.deleteSemaphore(* mutex1);  
    obj.deleteSemaphore(* wrt);  
    return 0;   
}  
void reader_writer () {}  

这是我得到的错误：

他们需要是哪种类型？ pthread_mutex_t_create？ 还是pthread_t_create？
什么是正确的类型？

Answer 1

类内部的函数称为方法。 您需要实例化该类的对象才能使用其方法：

myCountingSemaphoreUsingBinarySemaphore obj; // obj is an instance of the class

obj.waitSemaphore(&mutex1);

obj.signalSemaphore(&mutex1);

编辑：

顺便说一句， pthread_create和pthread_join使用pthread_t*而不是互斥锁！

int pthread_create(pthread_t* thread, 
                   pthread_attr_t* attr, 
                   void* (*start_routine)(void*), 
                   void* arg);

Answer 2

您可以将这些方法声明为静态方法，也可以使用对象进行调用：

myCountingSemaphoreUsingBinarySemaphore s;
s.waitSemaphore(wrt);

Answer 3

您正在将类方法仅作为waitSemaphore调用，而没有创建waitSemaphore的对象。

您应该首先创建对象。

myCountingSemaphoreUsingBinarySemaphore obj;
obj.waitSemaphore(mutex1);

Answer 4

您创建的两个线程（通过reader_writer() ） reader_writer() 。 main()只是进入第一个do循环而无法退出。

另外，您似乎对互斥量，信号量和条件变量感到困惑。 函数名称使其看起来像您在尝试在类中实现条件变量。 但是您将其构建为互斥锁的包装器。

最后，您正在调用pthread_mutex_lock()等。 当应该在pthread_mutex_t上调用这些函数时，在pthread_t上调用这些函数。

可能还有其他错误，但是这些错误确实会跳出来。 基本上，您需要在如何创建线程以及如何同步线程方面都审查多线程编程。

Answer 5

您需要创建类（对象）的实例才能调用其成员函数。

在此特定代码中，成员函数没有理由成为实例，并且可以是静态的：

class foo{
    public:

    static void bar(int val)
    {
    //do something
    }
    };

int main()
{
   foo::bar(10);
}

Answer 6

karlphillip是正确的，您需要通过指针而不是引用来传递

顺便说一句，下一行也是错误的，pthread_create accept和pthread_t而不是pthread_mutex_t

pthread_create（＆mutex1，NULL，reader_writer，void）;

pthread_create（＆wrt，NULL，reader_writer，void）;