C++ 使用命令行参数选择数据类型？

基本上，根据用户是输入0还是输入1作为命令行参数，我希望数据类的数据成员是向量还是数组（静态）。我不相信您可以将if语句添加到.h文件中，但我希望执行以下操作：

/*A.h*/
//various functions
private:
if(argv[1] == 0)
    vector b;
else if(argv[1] == 1)
    array b[10];

---

有没有一个简单的方法可以做到这一点？谢谢

C-type数组和std:：vector有非常不同的接口，所以即使您能够做到这一点，也很难编写有意义的代码，因为vector有push_back（）、empty（）等，而数组没有

---

您所寻找的是一个具有一致接口的对象类型，它可以在引擎盖下实现多个实现（可以使用C样式数组或C++标准向量实现）。这就是所谓的多态性，并且在这里可以找到如何用C++实现这一点：

C型数组和STD:：vector有非常不同的接口，所以即使你能做到这一点，编写有意义的代码也会很困难，如vector有PuxOffBuffE（）、EMPTY（）等等，而数组则没有。

---

您所寻找的是一个具有一致接口的对象类型，它可以在引擎盖下实现多个实现（可以使用C样式数组或C++标准向量实现）。这就是所谓的多态性，并且在这里可以找到如何用C++实现这一点：

C型数组和STD:：vector有非常不同的接口，所以即使你能做到这一点，编写有意义的代码也会很困难，如vector有PuxOffBuffE（）、EMPTY（）等等，而数组则没有。

---

您所寻找的是一个具有一致接口的对象类型，它可以在引擎盖下实现多个实现（可以使用C样式数组或C++标准向量实现）。这就是所谓的多态性，并且在这里可以找到如何用C++实现这一点：

C型数组和STD:：vector有非常不同的接口，所以即使你能做到这一点，编写有意义的代码也会很困难，如vector有PuxOffBuffE（）、EMPTY（）等等，而数组则没有。

---

您所寻找的是一个具有一致接口的对象类型，它可以在引擎盖下实现多个实现（可以使用C样式数组或C++标准向量实现）。这就是所谓的多态性，并且在这里可以找到如何用C++实现这一点：

< P>一个实现这一点的方法是使用模板辅助函数。但是请注意，如果代码复杂，这可能会导致大量代码重复。但我猜这是为了不同实现方法的性能度量（否则程序用户为什么会关心它是如何实现的），我猜代码并不太复杂

例如：

template<typename type_to_use> int template_main(int argc, char* argv[])
{
  type_to_use b;
  // ...
}

int main(int argc, char* argv[])
{
  if (argv[1]==0)
    template_main<vector>(argc, argv);
  else
    template_main<int[10]>(argc, argv);
}

template int template_main（int-argc，char*argv[]）
{
输入_至_使用b；
// ...
}
int main（int argc，char*argv[]）
{
如果（argv[1]==0）
模板_main（argc、argv）；
其他的
模板_main（argc、argv）；
}

实现这一点的一种方法是使用模板辅助函数。但是请注意，如果代码复杂，这可能会导致大量代码重复。但我猜这是为了不同实现方法的性能度量（否则程序用户为什么会关心它是如何实现的），我猜代码并不太复杂

例如：

template<typename type_to_use> int template_main(int argc, char* argv[])
{
  type_to_use b;
  // ...
}

int main(int argc, char* argv[])
{
  if (argv[1]==0)
    template_main<vector>(argc, argv);
  else
    template_main<int[10]>(argc, argv);
}

template int template_main（int-argc，char*argv[]）
{
输入_至_使用b；
// ...
}
int main（int argc，char*argv[]）
{
如果（argv[1]==0）
模板_main（argc、argv）；
其他的
模板_main（argc、argv）；
}

实现这一点的一种方法是使用模板辅助函数。但是请注意，如果代码复杂，这可能会导致大量代码重复。但我猜这是为了不同实现方法的性能度量（否则程序用户为什么会关心它是如何实现的），我猜代码并不太复杂

例如：

template<typename type_to_use> int template_main(int argc, char* argv[])
{
  type_to_use b;
  // ...
}

int main(int argc, char* argv[])
{
  if (argv[1]==0)
    template_main<vector>(argc, argv);
  else
    template_main<int[10]>(argc, argv);
}

template int template_main（int-argc，char*argv[]）
{
输入_至_使用b；
// ...
}
int main（int argc，char*argv[]）
{
如果（argv[1]==0）
模板_main（argc、argv）；
其他的
模板_main（argc、argv）；
}

实现这一点的一种方法是使用模板辅助函数。但是请注意，如果代码复杂，这可能会导致大量代码重复。但我猜这是为了不同实现方法的性能度量（否则程序用户为什么会关心它是如何实现的），我猜代码并不太复杂

例如：

template<typename type_to_use> int template_main(int argc, char* argv[])
{
  type_to_use b;
  // ...
}

int main(int argc, char* argv[])
{
  if (argv[1]==0)
    template_main<vector>(argc, argv);
  else
    template_main<int[10]>(argc, argv);
}

template int template_main（int-argc，char*argv[]）
{
输入_至_使用b；
// ...
}
int main（int argc，char*argv[]）
{
如果（argv[1]==0）
模板_main（argc、argv）；
其他的
模板_main（argc、argv）；
}

有没有一个简单的方法可以做到这一点

是：使用一个基类定义的公共接口创建两个不同的实现。然后，使用类工厂根据运行时参数实例化其中一个

class data {
public:
    virtual ~data() = 0;
    // define public interface here
};

class vector_data: public data {
    std::vector<int> values;
public:
    // implement public interface here in terms of values
};

class array_data: public data {
    int values[20]; // or, std::array<int, 10> values;
public:
    // implement public interface here in terms of values
};

std::unique_ptr<data> make_data(bool vector_data)
{
    if(vector_data)
        return { new vector_data() };
    return { new array_data(); }
}

int main(int argc, char* argv[])
{
    std::vector<std::string> args{ argv, argv + argc };
    auto data = make_data( args[1] == "vector" };
}

有没有一个简单的方法可以做到这一点

是：使用一个基类定义的公共接口创建两个不同的实现。然后，使用类工厂根据运行时参数实例化其中一个

class data {
public:
    virtual ~data() = 0;
    // define public interface here
};

class vector_data: public data {
    std::vector<int> values;
public:
    // implement public interface here in terms of values
};

class array_data: public data {
    int values[20]; // or, std::array<int, 10> values;
public:
    // implement public interface here in terms of values
};

std::unique_ptr<data> make_data(bool vector_data)
{
    if(vector_data)
        return { new vector_data() };
    return { new array_data(); }
}

int main(int argc, char* argv[])
{
    std::vector<std::string> args{ argv, argv + argc };
    auto data = make_data( args[1] == "vector" };
}

有没有一个简单的方法可以做到这一点

是：使用一个基类定义的公共接口创建两个不同的实现。然后，使用类工厂根据运行时参数实例化其中一个

class data {
public:
    virtual ~data() = 0;
    // define public interface here
};

class vector_data: public data {
    std::vector<int> values;
public:
    // implement public interface here in terms of values
};

class array_data: public data {
    int values[20]; // or, std::array<int, 10> values;
public:
    // implement public interface here in terms of values
};

std::unique_ptr<data> make_data(bool vector_data)
{
    if(vector_data)
        return { new vector_data() };
    return { new array_data(); }
}

int main(int argc, char* argv[])
{
    std::vector<std::string> args{ argv, argv + argc };
    auto data = make_data( args[1] == "vector" };
}

有没有一个简单的方法可以做到这一点

是：使用一个基类定义的公共接口创建两个不同的实现。然后，使用类工厂根据运行时参数实例化其中一个

class data {
public:
    virtual ~data() = 0;
    // define public interface here
};

class vector_data: public data {
    std::vector<int> values;
public:
    // implement public interface here in terms of values
};

class array_data: public data {
    int values[20]; // or, std::array<int, 10> values;
public:
    // implement public interface here in terms of values
};

std::unique_ptr<data> make_data(bool vector_data)
{
    if(vector_data)
        return { new vector_data() };
    return { new array_data(); }
}

int main(int argc, char* argv[])
{
    std::vector<std::string> args{ argv, argv + argc };
    auto data = make_data( args[1] == "vector" };
}

---

这是一个实现问题，应该在StackOverflow.SE上提问。实现这一点有不同的方法，但最简单的方法是在这两种情况下都使用向量。你应该解释一下为什么我不能