c++ - 将库链接在一起时的 boost::signals2 undefined-reference

Question

我想将两个库链接到我的程序。第一个，定义了一个发出信号的对象(类ProducerObject)。第二个库定义了两个类:一个包含多个 ProducerObject 实例的从属类和一个可以通过从属类订阅 ProducerObject 信号的主类。 p>

第一个lib的代码是:
ProducerObject.hpp:

#ifndef PRODUCEROBJECT_HPP_
#define PRODUCEROBJECT_HPP_

#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <boost/function.hpp> // shouldn't be needed


namespace testnm {

class ProducerObject {
public:
    typedef boost::signals2::signal<void (boost::shared_ptr<int>)> broadcast_signal_t;
    typedef broadcast_signal_t::slot_type broadcast_slot_t;

private:
    broadcast_signal_t  sig_;

public:
    ProducerObject();
    virtual ~ProducerObject();

    boost::signals2::connection connect(const broadcast_slot_t& slot);
    boost::signals2::connection connect2(const boost::function<void(boost::shared_ptr<int>)>& slot); // shouldn't be needed
    void sendMessage(boost::shared_ptr<int> msg);

};

} /* namespace testnm */
#endif /* PRODUCEROBJECT_HPP_ */

ProducerObject.cpp:

#include "ProducerObject.hpp"

namespace testnm {

ProducerObject::ProducerObject() {

}

ProducerObject::~ProducerObject() {

}

boost::signals2::connection ProducerObject::connect(const broadcast_slot_t& slot) {
    return sig_.connect(slot);
}

// shouldn't be needed
boost::signals2::connection ProducerObject::connect2(const boost::function<void(boost::shared_ptr<int>)>& slot) {
    return connect(slot);
}

void ProducerObject::sendMessage(boost::shared_ptr<int> msg) {
    sig_(msg);
}

} /* namespace testnm */

在与代码同级的Debug目录中编译此命令:

g++ -O0 -g3 -Wall -c -fmessage-length=0 -fPIC -MMD -MP -MF"ProducerObject.d" -MT"ProducerObject.d" -o "ProducerObject.o" "../ProducerObject.cpp"

g++ -shared -o "libProducerObject.so" ./ProducerObject.o

第二个库的代码是:
MasterAPI.hpp:

#ifndef MASTERAPI_HPP_
#define MASTERAPI_HPP_

#include "SlaveAPI.hpp"

#include <ProducerObject.hpp>

#include <iostream>

#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>


namespace testnm {

class MasterAPI {
private:
    int id_;

public:
    MasterAPI(const int& id);
    virtual ~MasterAPI();

    void subscribeToProducer(boost::shared_ptr<SlaveAPI> slave, const unsigned long int& producerid);

    virtual void onMessage(boost::shared_ptr<int> msg);

};

} /* namespace testnm */
#endif /* MASTERAPI_HPP_ */

从站API.hpp:

#ifndef SLAVEAPI_HPP_
#define SLAVEAPI_HPP_

#include <ProducerObject.hpp>

#include <boost/shared_ptr.hpp>

namespace testnm {

class MasterAPI; // forward declaration

class SlaveAPI {
public:
    SlaveAPI();
    virtual ~SlaveAPI();

    virtual boost::shared_ptr<ProducerObject> getProducer(const unsigned long int& producerid) const = 0;

    void sendDedicatedMessage(const boost::shared_ptr<MasterAPI> master, boost::shared_ptr<int> msg);

};

} /* namespace testnm */

#include "MasterAPI.hpp" // full declaration of the 'MasterAPI' class
                         // (used in the implementation of the method 'sendDedicatedMessage')

#endif /* SLAVEAPI_HPP_ */

奴隶基地.hpp:

#ifndef SLAVEBASE_HPP_
#define SLAVEBASE_HPP_

#include "SlaveAPI.hpp"

#include <ProducerObject.hpp>

#include <unordered_map>

#include <boost/shared_ptr.hpp>


namespace testnm {

class SlaveBase : public SlaveAPI {
private:
    std::unordered_map<unsigned long int, boost::shared_ptr<ProducerObject> >   producers_;

public:
    SlaveBase();
    virtual ~SlaveBase();

    virtual boost::shared_ptr<ProducerObject> getProducer(const unsigned long int& producerid) const;

};

} /* namespace testnm */
#endif /* SLAVEBASE_HPP_ */

MasterAPI.cpp:

#include "MasterAPI.hpp"

namespace testnm {

MasterAPI::MasterAPI(const int& id) :id_(id) {

}

MasterAPI::~MasterAPI() {

}

void MasterAPI::subscribeToProducer(boost::shared_ptr<SlaveAPI> slave, const unsigned long int& producerid) {
    boost::shared_ptr<ProducerObject> producer = slave->getProducer(producerid);
    //producer->connect((ProducerObject::broadcast_slot_t)(boost::bind(&MasterAPI::onMessage, this, _1))); // shouldn't be commented
    producer->connect2(boost::bind(&MasterAPI::onMessage, this, _1)); // shouldn't be needed
}

void MasterAPI::onMessage(boost::shared_ptr<int> msg) {
    std::cout << "Message received in MasterAPI(" << id_ << "): value = " << *msg << std::endl;
}

} /* namespace testnm */

从属API.cpp:

#include "SlaveAPI.hpp"

namespace testnm {

SlaveAPI::SlaveAPI() {

}

SlaveAPI::~SlaveAPI() {

}

void SlaveAPI::sendDedicatedMessage(const boost::shared_ptr<MasterAPI> master, boost::shared_ptr<int> msg) {
    master->onMessage(msg);
}

} /* namespace testnm */

SlaveBase.cpp:

#include "SlaveBase.hpp"

namespace testnm {

SlaveBase::SlaveBase() {
    boost::shared_ptr<ProducerObject> producer(new ProducerObject);
    producers_[1] = producer;
    producer.reset(new ProducerObject);
    producers_[2] = producer;
}

SlaveBase::~SlaveBase() {

}

boost::shared_ptr<ProducerObject> SlaveBase::getProducer(const unsigned long int& producerid) const {
    std::unordered_map<unsigned long int, boost::shared_ptr<ProducerObject> >::const_iterator prod_it = producers_.find(producerid);
    if (prod_it == producers_.end())
        return boost::shared_ptr<ProducerObject>();
    return prod_it->second;
}

} /* namespace testnm */

编译这段代码:

g++ -I"/home/chris/workspace/ProducerObject" -O0 -g3 -Wall -c -fmessage-length=0 -std=c++0x -fPIC -MMD -MP -MF"MasterAPI.d" -MT"MasterAPI.d" -o "MasterAPI.o" "../MasterAPI.cpp"

g++ -I"/home/chris/workspace/ProducerObject" -O0 -g3 -Wall -c -fmessage-length=0 -std=c++0x -fPIC -MMD -MP -MF"SlaveAPI.d" -MT"SlaveAPI.d" -o "SlaveAPI.o" "../SlaveAPI.cpp"

g++ -I"/home/chris/workspace/ProducerObject" -O0 -g3 -Wall -c -fmessage-length=0 -std=c++0x -fPIC -MMD -MP -MF"SlaveBase.d" -MT"SlaveBase.d" -o "SlaveBase.o" "../SlaveBase.cpp"

g++ -L"/home/chris/workspace/ProducerObject/Debug" -shared -o "libObjectAPI.so" ./MasterAPI.o ./SlaveAPI.o ./SlaveBase.o -lProducerObject

最后，程序本身:
ObjectTest.cpp:

#include <ProducerObject.hpp>
#include <SlaveBase.hpp>
#include <MasterAPI.hpp>

#include <iostream>

#include <boost/shared_ptr.hpp>


using namespace std;
using namespace testnm;

int main(int argc, char* argv[]) {
    boost::shared_ptr<SlaveBase> slave(new SlaveBase);
    boost::shared_ptr<MasterAPI> master1(new MasterAPI(1)), master2(new MasterAPI(2));

    master1->subscribeToProducer(slave, 1);
    master1->subscribeToProducer(slave, 2);
    master2->subscribeToProducer(slave, 1);

    cout << "--> sending a dedicated message to master1:" << endl;
    boost::shared_ptr<int> msg(new int(11));
    slave->sendDedicatedMessage(master1, msg);

    cout << "\n--> sending a broadcast message from procuder1:" << endl;
    boost::shared_ptr<ProducerObject> producer1 = slave->getProducer(1);
    msg.reset(new int(22));
    producer1->sendMessage(msg);

    cout << "\n--> sending a broadcast message from procuder2:" << endl;
    boost::shared_ptr<ProducerObject> producer2 = slave->getProducer(2);
    msg.reset(new int(33));
    producer2->sendMessage(msg);

    return 0;
}

编译:

g++ -I"/home/chris/workspace/ProducerObject" -I"/home/chris/workspace/ObjectAPI" -O0 -g3 -Wall -c -fmessage-length=0 -std=c++0x -MMD -MP -MF"ObjectTest.d" -MT"ObjectTest.d" -o "ObjectTest.o" "../ObjectTest.cpp"

g++ -L"/home/chris/workspace/ProducerObject/Debug" -L"/home/chris/workspace/ObjectAPI/Debug" -o "ObjectTest" ./ObjectTest.o -lObjectAPI -lProducerObject

此程序产生以下输出，这正是我们想要的:

--> sending a dedicated message to master1:
Message received in MasterAPI(1): value = 11

--> sending a broadcast message from procuder1:
Message received in MasterAPI(1): value = 22
Message received in MasterAPI(2): value = 22

--> sending a broadcast message from procuder2:
Message received in MasterAPI(1): value = 33

为了产生这个输出，我不得不依赖辅助方法 connect2，它以 boost::function 作为参数。我想避免这种情况，因为插槽的签名应该已经包含在 *broadcast_slot_t* 类型中。因此，我想要实现的代码版本不包含 connect2 方法。但是，如果我在方法 MasterAPI::subscribeToProducer 的实现中从 connect2 切换到 connect (只需更改要测试的注释)，最后编译阶段(一切都链接在一起)产生以下错误:

> /home/chris/workspace/ObjectAPI/Debug/libObjectAPI.so: undefined reference to `testnm::ProducerObject::connect(boost::signals2::slot<void (boost::shared_ptr<int>), boost::function<void (boost::shared_ptr<int>)> > const&)'  
> collect2: error: ld returned 1 exit status  
> make: *** [ObjectTest] Error 1

为什么以及如何避免？

Answer 1

长话短说，您永远不能将使用 -stdc=c++0x 编译的对象与没有编译的对象组合在一起。您很幸运遇到链接器错误而不是神秘的崩溃。