c++ - boost::signals2 ライブラリをリンクするときの undefined-reference

Question

2 つのライブラリを自分のプログラムにリンクしたいと考えています。最初のものは、シグナルを発する(クラスProducerObjectの) オブジェクトを定義します。2 番目のライブラリは 2 つのクラスを定義します。1 つはProducerObjectの複数のインスタンスを含むスレーブクラス、もう 1 つはスレーブクラスを介してProducerObjectのシグナルをサブスクライブできるマスタークラスです。

最初のライブラリのコードは次のとおりです。
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

2 番目のライブラリのコードは次のとおりです
。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_ */

SlaveAPI.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_ */

SlaveBase.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 */

SlaveAPI.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

このプログラムは次の出力を生成します。これはまさに必要なものです。

--> 専用メッセージを master1 に送信:
MasterAPI(1) で受信したメッセージ: 値 = 11

--> procuder1 からのブロードキャストメッセージの送信:
MasterAPI(1) で
受信したメッセージ: 値 = 22 MasterAPI(2) で受信したメッセージ: 値 = 22

--> procuder2 からのブロードキャストメッセージの送信:
MasterAPI(1) で受信したメッセージ: 値 = 33

この出力を生成するには、引数としてboost::functionを取る補助メソッドconnect2に依存する必要がありました。スロットの署名は既に *broadcast_slot_t* タイプに含まれている必要があるため、これは避けたいと思います。したがって、達成したいコードのバージョンにはconnect2メソッドが含まれていません。しかし、メソッドMasterAPI::subscribeToProducerの実装でconnect2からconnectに切り替えると (コメントを test に変更するだけです)、最後のコンパイルフェーズ (すべてがリンクされている場所) で次のエラーが発生します。

> /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

なぜ、どのように回避するのですか？

c++ - boost::signals2 ライブラリをリンクするときの undefined-reference

1 に答える 1

Related

Reference