我想将两个库链接到我的程序。第一个定义了一个发出信号的对象（类ProducerObject）。第二个库定义了两个类：一个从属类，它包含多个ProducerObject的实例以及一个可以通过从属类订阅ProducerObject的信号的主类。boost :: signals2未定义 - 将库链接在一起时的引用
第一IIb的代码是：
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_ */
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
最后，PROGRAMM本身：
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方法。但是，如果我从CONNECT2切换到的方法的实现连接 MasterAPI :: subscribeToProducer（只需修改意见进行测试），最后编译阶段（这里的一切都连接在一起）产生以下错误：
> /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
为什么以及如何避免它？
为什么使用'-L'将目录添加到'-l'的搜索路径中，而不是'-l'？ – curiousguy
嗯，我刚刚根据我的程序创建了一个示例来说明我的问题。我使用Eclipse（CDT）并且编译的命令是由Eclipse生成的。但是如果你看起来很好，你会看到'-l'被用来包含库。 – Chris
为什么你有'（const int＆id）'参数而不是'int'？ – curiousguy