我想将两个库链接到我的程序。第一个，定义一个发出信号的对象（属于ProducerObject类）。第二个库定义了两个类：一个包含多个ProducerObject实例的从属类和一个可以通过从属类订阅ProducerObject信号的主类。
第一个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_ */
生产者对象.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_ */
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 */
从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
该程序产生以下输出，这正是我们想要的：
--> 向 master1 发送专用消息：
在 MasterAPI(1) 中收到的消息：值 = 11--> 从 procuder1 发送广播消息：
MasterAPI(1) 中
收到的消息： value = 22 MasterAPI(2) 中收到的消息： value = 22--> 从 procuder2 发送广播消息：
MasterAPI(1) 中收到的消息：值 = 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
为什么以及如何避免它？