I have a object cache class like this:
#include "boost/thread/mutex.hpp"
#include "boost/unordered_map.hpp"
template <typename type1, typename type2>
class objectCache
{
public:
objectCache()
{
IDCounter = 0;
}
~objectCache()
{
for ( it=free_objects.begin() ; it != free_objects.end(); it++ )
delete (*it).second;
for ( it=busy_objects.begin() ; it != busy_objects.end(); it++ )
delete (*it).second;
}
type1* objectCache::Get()
{
boost::mutex::scoped_lock(io_mutex);
if(free_objects.size() > 0)
{
it = free_objects.begin();
type1 *temp = (*it).second;
busy_objects[(*it).first] = temp;
free_objects.erase(free_objects.begin());
return temp;
}
type1 * temp = new type2;
++IDCounter;
busy_objects[IDCounter] = temp;
return temp;
}
void objectCache::Pushback(type1)
{
boost::mutex::scoped_lock(io_mutex);
free_objects[ID] = socket;
it = busy_objects.find(ID);
busy_objects.erase(it);
}
protected:
private:
boost::mutex io_mutex;
long long IDCounter;
boost::unordered_map<long long, type1*> free_objects;
boost::unordered_map<long long, type1*> busy_objects;
typename boost::unordered_map<long long, type1*>::iterator it;
};
class A{
public:
A(int num){
number = num;
}
int number;
};
int main(int argc, char* argv[])
{
objectCache<a, a(1)> intcache;
A* temp = intcache.Get();
cout <<temp->number <<endl;
system("pause");
return 0;
}
I known that "typename type2" was unnecessary but I need a way to pass a class object that have a constructor with parameter like class A to the template. or their was another way to do this ? please help.
You can have the template parameter on the method:
template <typename type2>
type1* objectCache::Get()
Do you want something like this?
template <typename type1>
class objectCache
{
// ...
template<typename type2>
type1* Get(type2 value)
{
boost::mutex::scoped_lock(io_mutex);
if(free_objects.size() > 0)
{
it = free_objects.begin();
type1 *temp = (*it).second;
busy_objects[(*it).first] = temp;
free_objects.erase(free_objects.begin());
return temp;
}
type1 * temp = new type1(value);
++IDCounter;
busy_objects[IDCounter] = temp;
return temp;
}
// ...
};
int main(int argc, char* argv[])
{
objectCache<A> intcache;
A* temp = intcache.Get(1);
cout << temp->number << endl;
system("pause");
return 0;
}
Rather than passing an explicit value, pass in an object that creates your instance for you:
template <typename type1>
struct DefaultInstanceCreator {
type1 * operator ()() const {
return new type1;
}
};
template < typename type1
, typename InstanceCreator = DefaultInstanceCreator<type1> >
class objectCache {
public:
objectCache (InstanceCreator const & instCreator)
: instCreator_ (instCreator) {
}
type1* Get() {
type1 * temp = instCreator_ ();
}
private:
InstanceCreator instCreator_;
};
Then your object can have it's own specific creator:
class A {
public:
A(int num){
number = num;
}
int number;
public:
struct CreateInstance {
CreateInstance (int value)
: value_ (value) {
}
A * operator ()() const {
return new A(value_);
}
int value_;
};
};
int main(int argc, char* argv[]) {
objectCache<A, A::CreateInstance> intcache ( A::CreateInstance (1) );
A* temp = intcache.Get();
return 0;
}
The advantage of this approach is that you can use your cache with objects that have different numbers of arguments to their constructors.
int main(int argc, char* argv[])
{
objectCache<a, a(1)> intcache;
...
}
is wrong. You are supposed to indicate the types used by the objectCache class. It should be something like
objectCache<A, A> intcache;
In the objectCache class when you instantiate objects of A, you will have to pass a parameter to its constructor.
For example:
...
type1 * temp = new type1(1);
...
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.