C++使用宏进行动态实例化
C++ dynamic instantiation using macro
我正在尝试在C++中实现动态实例化,我的意思是从类字符串创建实例。但是经过一番挖掘,我发现C++似乎本身并不支持这样的功能。
例如,我有一个名为Person
的"接口",以及一些具体的实现,如Worker
、Teacher
、Programmer
等。在C++中,如果我想将所有实现存储到一个地图collection
中,我必须编写这样的东西:
#include <map>
#include <string>
#include "Worker.hpp"
#include "Teacher.hpp"
#include "Programmer.hpp"
// ...
using namespace std;
int main() {
map<string, Person*> collection;
Worker worker;
Teacher teacher;
Programmer monkey;
// ...
collection[worker->title] = &worker;
collection[teacher->title] = &teacher;
collection[monkey->tittle] = &monkey;
// ...
}
这似乎没问题,但我不喜欢每次添加职位时都更改代码中的三个位置。 我想做的看起来像这样:
#include <map>
#include <string>
#include "Worker.hpp"
#include "Teacher.hpp"
#include "Programmer.hpp"
# ...
using namespace std;
int main() {
map<string, Person*> collection;
char titles[][20] = {"Worker", "Teacher", "Programmer"};
for (auto const &Title: titles) {
// this is the magic I would like to have.
Title object;
collection[title] = &object;
}
}
不幸的是,C++没有魔法。
所以过了一会儿,我意识到有宏和预处理器,也许我可以绕过它。这就是我到目前为止能想到的:
#include <map>
#include <string>
#include <iostream>
#include "Worker.hpp"
#include "Teacher.hpp"
#include "Programmer.hpp"
# ...
#define PUSH(name)
name o_##name;
collection[o_##name.title] = &o_##name;
using namespace std;
int main() {
map<string, Person*> collection;
PUSH(Worker);
PUSH(Teacher);
PUSH(Programmer);
return 0;
}
我试图自动化#include
指令,但似乎宏没有变量的概念。 并且预处理器不会对宏进行两次解释。
知道我如何实现类似的东西吗?
我知道把我的头埋在这么徒劳的事情上听起来很愚蠢,但这只是我的特点,如果它没有被证明是对还是错,我就无法摆脱这个想法。
我非常感谢您的建议。
编辑:
感谢您为帮助我所做的一切努力。我对这个问题有点不清楚。我真正想要实现的是
我想创建许多程序,让用户决定运行什么。潜在的问题是,我最终可能会有大量if-else
语句让用户决定运行什么,因为我想在项目中编写大量小段代码。
我不确定这次我是否说清楚了。但是我已经放弃了这个想法,并使用测试框架来完成这项工作。
再次感谢大家。
C++有魔力,它被称为模板。
你可以使用这样的东西...
#include <string>
#include <iostream>
#include <map>
template<class T>
struct make_object {
static_assert(std::is_convertible<T*, Person*>::value, "Object must be derived from Person");
T* object;
make_object() : object(new T) {}
};
//** For iterating over the tuple and inserting each person into the collection
template<std::size_t I = 0, class MAP, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
insertPeople(MAP& collection, std::tuple<Tp...>& t)
{ }
template<std::size_t I = 0, class MAP, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
insertPeople(MAP& collection, std::tuple<Tp...>& t)
{
auto object = std::get<I>(t).object;
collection[object->title] = object;
insertPeople<I + 1, MAP, Tp...>(collection, t);
}
//** Creates the tuple containing the objects
template<class... CLASSES>
void createPeople(std::map<std::string, Person*>& collection)
{
std::tuple<make_object<CLASSES>...> objects;
insertPeople(collection, objects);
}
int main()
{
std::map<std::string, Person*> collection;
createPeople<Worker, Teacher, Progammer>(collection);
for (auto person : collection)
std::cout << person.second->title << std::endl;
return 0;
}
完成后不要忘记删除所有对象。或者,您可以使用唯一/共享指针。
这个问题在类型关系、生存期等方面有点不清楚,但以下代码可能是你要求的主要方向。
这个想法是使用动态分配的对象和智能指针(如shared_ptr
(来管理它们的生存期。
#include <iostream>
#include <map> // std::(multimap>
#include <memory> // std::(make_shared, shared_ptr)
#include <stdlib.h> // rand, srand
#include <string>
#include <time.h> // time
using namespace std;
class Person
{
string m_name;
public:
auto name() const -> string { return m_name; }
virtual auto profession() const -> string { return ""; }
Person( const string& name ): m_name( name ) {}
virtual ~Person() = default;
};
class Worker:
public Person
{
public:
auto profession() const -> string override { return "Worker"; }
Worker( const string& name ): Person( name ) {}
};
class Teacher:
public Worker
{
public:
auto profession() const -> string override { return "Teacher"; }
Teacher( const string& name ): Worker( name ) {}
};
class Programmer:
public Worker
{
public:
auto profession() const -> string override { return "Programmer"; }
Programmer( const string& name ): Worker( name ) {}
};
using Profession_map = multimap<string, shared_ptr<Person>>;
void add_to( Profession_map& persons, const shared_ptr<Person> someone )
{
persons.emplace( someone->profession(), someone );
};
void list( const Profession_map& persons, const string& profession )
{
const string profession_description = ( 0?""
: profession == ""? "Unknown profession person"
: profession == "Worker"? "Generic worker"
: profession
);
const int n_registered = persons.count( profession );
if( n_registered == 1 )
{
cout << "There is 1 " << profession_description;
}
else
{
cout << "There are " << n_registered << " " << profession_description << "s";
}
if( n_registered > 0 )
{
cout << ": ";
const auto registered = persons.equal_range( profession );
int i = 0;
for( auto it = registered.first; it != registered.second; ++it, ++i )
{
if( it != registered.first ) { cout << (i == n_registered - 1? " and " : ", "); }
const shared_ptr<Person> p_person = it->second;
cout << p_person->name();
}
}
cout << "." << endl;
}
auto main()
-> int
{
Profession_map persons;
srand( time( nullptr ) ); // Seed for rand() sequence.
for( const string& name : {"alfa", "beta", "charlie", "delta", "echo", "foxtrot"} )
{
switch( rand() % 4 )
{
case 0: add_to( persons, make_shared<Person>( name ) ); break;
case 1: add_to( persons, make_shared<Worker>( name ) ); break;
case 2: add_to( persons, make_shared<Teacher>( name ) ); break;
case 3: add_to( persons, make_shared<Programmer>( name ) ); break;
}
}
list( persons, "" );
list( persons, "Worker" );
list( persons, "Teacher" );
list( persons, "Programmer" );
}
- 从C++实例化QML
- 设计一个只能由特定类实例化的类(如果可能的话,通过make_unique)
- 如何创建一个空的全局类并在启动时实例化它
- 我有一个对象,它将在整个程序的持续时间内实例化,但一个类成员不会,我应该动态分配它吗?
- 使用动态实例化的对象填充矢量的快速方法
- C++使用宏进行动态实例化
- 使用动态布尔变量实例化模板
- 使用标准类型的动态类型信息实例化标识符
- 有没有办法在C++中动态实例化"custom"类
- 显式实例化模板的动态使用
- 抽象类实例的动态初始化
- 只有当类重写方法时,在动态加载的共享库中实例化的类才会丢失XCode 4.3/4.4 typeinfo
- 动态实例化类,然后立即将其删除
- 类模板的动态实例化是否被视为显式或隐式
- 在使用包含类的动态实例化后调用 c++ 重载运算符 [] 似乎不起作用
- 动态和顺序命名和实例化小部件qt
- 动态实例化和初始化结构
- C++向量元素是否动态实例化
- 功能与安全/静态与动态实例化
- 如何从另一个实例的类型动态实例化新实例?C++