所以，这基本上就是我想要做的:

#define RS03(obj, a1, a2, a3) {if (_str1 == #a1) _file >> _##a1; if (_str1 == #a2) _file >> _##a2;if (_str1 == #a3) _file >> _##a3; obj (_##a1, _##a2, _##a3);}

这是三个参数的情况，但我还需要:

#define RS04(obj, a1, a2, a3, a4)
#define RS05(obj, a1, a2, a3, a4, a5)
#define RS06(obj, a1, a2, a3, a4, a5, a6)
...

所以是一个可变参数宏。

Stackoverflow 上有很多关于此类主题的问题，但它们不适用于我的情况。

在上面的代码中，三个参数 a1、a2 和 a3 既用作字符串(在“if”条件中)又用作变量(在赋值和构造函数中)，而 obj 是一个类(因此宏中的最后一个命令是构造函数调用)。

要点是:假设我有二十个不同的类，每个类都需要不同数量的输入来构建。

宏接收类的名称和构建此类对象所需的参数名称。

要点是(参见下面的“设计原因”)我需要在“if”条件下使用参数的名称，就像字符串一样。这就是为什么我使用宏(具有 # 和 ## 特殊字符的良好特性)而不是模板函数的原因。

基本上，我需要一个纯文本转换(因此是一个宏，而不是一个函数)，但带有参数的变量名。

这样设计的原因

让我们假设我有二十个不同的类，每一个都与另一个非常不同(例如，类 1 可以用两个 double 构造，类 2 需要一个 double 和两个整数，类 3 可以用两个构造 bool 等...)。

所有这些类都有一个“运行”成员函数，它产生相同格式的输出。

我的程序应该执行以下操作:

1 - 读取文本文件

2 - 为文件中描述的每个模型启动运行

文件应该是这样的:

car {
    name = model1
    speed = 0.05
}

man {
    name = model2
    speed = 0.03
    male = true
    ageclass = 3
}

...

所以我需要读取这样的文件并初始化文件中描述的每个类。

参数应该按照用户喜欢的任何顺序编写。

此外，它们可能出现不止一次，例如:

car {
    name = pippo
    speed = 0.05
    speed = 0.06
    speed = 0.07
}

(在这种情况下，最后一个将覆盖另一个)

如果用户忘记了某些参数，程序应该停止并显示一条明确的错误消息。

同一类型可能有不同的模型(例如，4 个不同的平面模型)。

例如，在这种情况下:

car {
    name = pippo
    speed = 0.05
}

car {
    name = pluto
}

程序应该说第二个模型是不完整的。

当然有很多方法可以做到这一点。

我是这样做的:

1 - 创建一个带有 T 成员(存储值)和 bool 成员(告诉我变量是否存在)的模板类(让我们称之为“字段”)

2 - 创建一个具有多个“字段”的对象(读取器，读取文件的对象)，每个字段对应一个可能的模型属性(_name、_speed、_male 等)

3 - 然后，在读取文件时，对于括号内的部分，我首先读取一个字符串(“标签”)，然后读取“=”，最后读取值。该值将存储在与字符串同名的变量中

(如果我找到“speed = 0.03”这一行，我将在读者的_name 字段中保存 0.03)。

这应该是伪代码(可能有错误，仅供说明):

if (car) {
    while (str != "}") {
        if (str == "speed")    { _file >> _speed;     _file >> _str; }
        if (str == "male")     { _file >> _male;      _file >> _str; }
        if (str == "ageclass") { _file >> _ageclass;  _file >> _str; }
        ERROR;
    }
    car (_speed.get (), _male.get (), _ageclass.get ());
}

get () 是“字段”类的成员函数，如果不可用(即文件中不存在)则引发异常，否则返回值(从文件读取)。

“字段”类还有一个重载运算符 >>，它对值应用标准运算符 >>，并将 bool 属性设置为 true。

由于模型太多，我想在宏中转换代码:-)

最佳答案

我不确定您是否有像我将要提议的那样彻底改变您的实现的自由，但这是我会做的。它不需要任何奇特的模板技术。

首先，您创建一个名为 Properies 的结构(例如)，其中包含任何类都可以禁止的所有属性。

struct Properties
{
    enum Types
    {
        MAN,
        CAR,
        // and more                                                                              
    };

    enum Gender
    {
        MALE, FEMALE
    };

    Types type;
    string name;
    double speed;
    Gender gender;
    int ageClass;
};

如您所见，它还包含一个描述每个现有类型的 enum。

接下来，您定义一个 Base 类型，您可以从中派生所有其他类型，如 Man、Car 等。

class Base
{};

class Man: public Base
{
    string d_name;
    Properties::Gender d_gender;
    int d_ageClass;
    double speed;

public:
    Man(Properties const &properties)
    {
        // Set properties that apply to the "Man"-class                                          
    }
};

class Car: public Base
{
    string d_name;
    double d_speed;

public:
    Car(Properties const &properties)
    {
        // Set properties that apply to the "Car"-class                                          
    }
};

每个类的构造函数都需要一个Properties 对象，它们从中提取适合它们的字段。例如，Car 构造函数不会检查 gender 字段，而 Man 构造函数会。

现在，您定义一个 Loader 类来处理解析。它包含一个返回 Base* vector 的成员 readFile，这样您就有了指向一个容器中所有已初始化对象的指针。我选择了 shared_ptr 来处理所有权问题，但您应该决定什么最适合您的应用程序。

class Loader
{
public:
    static vector<shared_ptr<Base>> readFile(string const &fileName)
    {
        vector< shared_ptr<Base> > result;
        ifstream file(fileName);
        // Parse the file, creating a "Properties" object, called                                
        // "props" here                                                                          

        while (file) // while EOF not reached.                                                   
        {
            Properties props = parse(file); // implement your parse                              
                                            // routine, returning Properties.                    
            switch (props.type)
            {
            case Properties::CAR:
                result.push_back(shared_ptr<Base>(new Car(props)));
                break;
            case Properties::MAN:
                result.push_back(shared_ptr<Base>(new Man(props)));
                break;
            // etc for all classes derived from Base                                             
            default:
                throw string("error: unknown type");
        }
    }
};

希望这对您有所帮助。

关于c++ - 没有 __VA_ARGS__ 的可变参数宏，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21607655/