C++ 通过函数指针传递参数时获取垃圾数据“

我正在使用函数指针将参数传递给函数。由于某种原因，当我在ClassA:：parseData的输出中传递参数时，我会得到垃圾数据。我正在分配int以将其保存在堆中，以便确保问题不是堆栈被清除，这就是变量不存在的原因。但是，这并没有解决问题m、 我曾尝试通过值、引用和指针传递int，但我总是得到垃圾数据。我做错了什么

A.h级

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

ClassA.cpp

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread((void (*)(int*)) &ClassA::parseData);
}

void ClassA::parseData(int* data){
    printf ("data received: %d \n", *data);
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread(&ClassA::parseData, this);
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

B.h类

class ClassB
{
    public:
        ClassB();
        ~ClassB();
        void* dataReader(void*);
        void startTheThread(void (*parseFunction)(int*));
        void (*_theParseFunction)(int*);
        pthread_t _theDataReaderThread;
};

#include <functional>
#include <pthread.h>

class ClassB
{
public:
    using ParseFunction = std::function<void(int*)>;
    ClassB();
    ~ClassB();
    static void* dataReader(void*);
    void startTheThread(ParseFunction parseFunction);
    ParseFunction _theParseFunction;
    pthread_t _theDataReaderThread;
};

#include <functional>
#include <thread>

class ClassB
{
public:
    using ParseFunction = std::function<void(int*)>;
    ClassB();
    ~ClassB();
    void dataReader();
    void startTheThread(ParseFunction parseFunction);
    ParseFunction _theParseFunction;
    std::thread _theDataReaderThread;
};

#include <pthread.h>

class ClassA;

class ClassB
{
public:
    typedef void (ClassA::*ParseFunction)(int*);
    ClassB();
    ~ClassB();
    static void* dataReader(void*);
    void startTheThread(ParseFunction parseFunction, ClassA*);
    ParseFunction _theParseFunction;
    ClassA *_theParseObj;
    pthread_t _theDataReaderThread;
};

类别b.cpp

int* intPointer;

ClassB::ClassB(){}

ClassB::~ClassB(){
    delete intPointer;
}

void* ClassB::dataReader(void*){
    intPointer = new int;
    *intPointer = 5;
    while (true){
        _theParseFunction(intPointer);
        sleep(2);
    }
}

void ClassB::startTheThread(void (*parseFunction)(int*)){
    _theParseFunction = parseFunction;

    int threadReturn = pthread_create(&_theDataReaderThread,
                                      NULL,
                                     (void* (*)(void*)) &ClassB::dataReader,
                                      this);
}

int* intPointer;

ClassB::ClassB(){}

ClassB::~ClassB(){
    delete intPointer;
}

void* ClassB::dataReader(void *arg){
    ClassB *pThis = static_cast<ClassB*>(arg);
    intPointer = new int(5);
    while (true){
        pThis->_theParseFunction(intPointer);
        sleep(2);
    }
}

void ClassB::startTheThread(ParseFunction parseFunction){
    _theParseFunction = std::move(parseFunction);

    int threadReturn = pthread_create(&_theDataReaderThread,
                                    NULL,
                                    &ClassB::dataReader,
                                    this);
}

int* intPointer;

ClassB::ClassB(){}

ClassB::~ClassB(){
    delete intPointer;
}

void ClassB::dataReader(){
    intPointer = new int(5);
    while (true){
        _theParseFunction(intPointer);
        sleep(2);
    }
}

void ClassB::startTheThread(ParseFunction parseFunction){
    _theParseFunction = std::move(parseFunction);
    _theDataReaderThread = std::thread([this](){ this->dataReader(); });
}

int* intPointer;

ClassB::ClassB(){}

ClassB::~ClassB(){
    delete intPointer;
}

void* ClassB::dataReader(void *arg){
    ClassB *pThis = static_cast<ClassB*>(arg);
    intPointer = new int(5);
    while (true){
        pThis->_theParseObj->*(pThis->_theParseFunction)(intPointer);
        sleep(2);
    }
}

void ClassB::startTheThread(ParseFunction parseFunction, ClassA *parseObj){
    _theParseFunction = parseFunction;
    _theParseObj = parseObj;

    int threadReturn = pthread_create(&_theDataReaderThread,
                                    NULL,
                                    &ClassB::dataReader,
                                    this);
}

主要方法

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

---

问题在于这些方面：

aClassB.startTheThread((void (*)(int*)) &ClassA::parseData);
...
pthread_create(&_theDataReaderThread,
                                      NULL,
                                     (void* (*)(void*)) &ClassB::dataReader,
                                      this);

这些类型转换无效。不能将非静态方法指针转换为这样的函数指针。pthread_create只需要独立的函数或类静态方法

如果您使用的是C++11或更高版本，请尝试以下方法：

A.h级

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

ClassA.cpp

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread((void (*)(int*)) &ClassA::parseData);
}

void ClassA::parseData(int* data){
    printf ("data received: %d \n", *data);
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread(&ClassA::parseData, this);
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

不过，您确实应该使用std:：thread而不是pthread\u create:

A.h级

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

ClassA.cpp

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread((void (*)(int*)) &ClassA::parseData);
}

void ClassA::parseData(int* data){
    printf ("data received: %d \n", *data);
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread(&ClassA::parseData, this);
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

主要方法

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

int main()
{
    ClassA aClassA = ClassA();
    aClassA.setFunctionPointers();

    while(true)
    {

    }

    return 0;
}

但是，如果您使用的是C++11之前的编译器，则必须使用指向成员函数的普通指针：

A.h级

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

class ClassA
{
public:
    ClassA();
    ~ClassA();
    void setFunctionPointers();
    void parseData(int* dataBuffer);
};

ClassA.cpp

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread((void (*)(int*)) &ClassA::parseData);
}

void ClassA::parseData(int* data){
    printf ("data received: %d \n", *data);
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread( [this](int *dataBuffer){ this->parseData(dataBuffer); } );
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

#include "ClassB.h"

ClassB aClassB;

ClassA::ClassA(){}

ClassA::~ClassA(){}

void ClassA::setFunctionPointers(){
    aClassB.startTheThread(&ClassA::parseData, this);
}

void ClassA::parseData(int* data){
    std::cout << "data received: " << *data << "\n";
}

---

pthread_create…void**void*&ClassB:：dataReader，这是完全无效的。FWIW如果您可以使用C++11或更好的，您可以使用std:：thread和lambda而不是pthread和void*。这使生活变得更简单。指向非静态成员函数的指针不能转换为指向函数的指针。如果您发现自己正在强制转换函数指针几乎可以肯定，从DLL加载函数是该规则的常见例外。如果将c样式强制转换替换为静态_强制转换的函数指针，您将看到编译器拒绝执行强制转换。成员使用隐式this指针，因此它不是e完全是同一个签名。在铸造成员函数之前无法编译它应该是一个很好的指示器，表明那里可能出了问题。