Question

我目前正在创建一个应用来启动外部应用。启动外部应用程序的签名是：

int launchApp(int argc, char** argv); // argc = amount of arguments, argv = arguments

要向std::vector<char *>结构添加参数，我使用以下lambda：

auto addArgument = [](std::vector<char *> & lArguments,
                       const std::string & sArgument)
{
   auto cstr = new char[sArgument.size() + 1];
   std::copy(sArgument.cbegin(), sArgument.cend(), cstr);
   cstr[sArgument.size()] = '\0';
   lArguments.push_back(cstr);
};

启动外部应用程序：

std::vector<char *> lArguments;
addArgument(lArguments, "Argument 1");
addArgument(lArguments, "Argument 2");
launchApp(lArguments.size(),static_cast<char**>(lArguments.data());
//... Clean up arguments

我将如何以RAII方式执行此操作？我正在考虑使用std::vector<std::vector<char>>代替。但是，如何将基础原始数据（char**）传递给launchApp()？ static_cast<char**>(lArguments.data())不会工作......

Answer 1

我通常分两部分来做这件事：

构建包含实际参数的std::vector<std::string>。
构建一个std::vector<const char*>，其中每个元素都是字符串向量中相应元素的.data()。

第一个向量及其中包含的字符串处理您的分配，调整大小等，而第二个向量仅作为第一个向量管理的内存的索引。第二个向量的生命周期应该比第一个向量的生命周期短，你可以通过将它们包装在一个类中来保证。

Example：

#include <string>
#include <vector>
#include <unistd.h>

int main() {
    std::vector<std::string> args = {"echo", "hello", "world"};
    std::vector<const char*> argv;
    argv.reserve(args.size());
    for (auto& arg : args) {
        argv.push_back(arg.data());
    }

    execvp("echo", const_cast<char**>(argv.data()));    
}

（请注意丑陋的const_cast。根据您的观察方式，这可能是因为exec*系列函数不遵循const正确性，或者因为std::string::data()没有非const版本（在C ++ 17之前））。

或者，with the class to wrap it all up nicely：

#include <string>
#include <vector>
#include <unistd.h>

class ExecArguments {
 public:
  ExecArguments(std::initializer_list<std::string> arguments)
   : args(arguments) {
       for (auto& arg : args) {
           argv.push_back(const_cast<char*>(arg.data()));
       }
   }

   char** data() {
       return const_cast<char**>(argv.data());
   }

 private:
  std::vector<std::string> args;
  std::vector<char*> argv;
};

int main() {
    ExecArguments args{"echo", "hello", "world"};

    execvp(args.data()[0], args.data());    
}

Answer 2

将参数收集为常规字符串。
使用以下内部类：
- 为原始指针数组提供透明隐式视图，
- 负责同时管理这个指针数组。

某个访问方法返回此内部类的实例。它的生命周期跨越了调用语句。请参阅下面的示例：

   #include <iostream>
   #include <vector>

   class CollectArgs : public std::vector<std::string> {
     // just for providing the raw view and taking care of its memory
     class RawArgs {
       std::vector<char const*>  m_argv;
     public:
       RawArgs(std::vector<char const*>  argv) {
         std::swap(argv, m_argv);
       }
       ~RawArgs() {}

     public:
       operator char const* const*() const { return  m_argv.data(); }
     };

   public:
     RawArgs raw_args() const {
       std::vector<char const*>  argv;
       for(std::string const &arg : *this)  argv.push_back(arg.c_str());
       return  argv;
     }
   };

   // the application launcher
   void call(unsigned  argc, char const *const *argv) {
     for(unsigned  i = 0; i < argc; i++) {
       std::cout << argv[i] << std::endl;
     }
   }

   int main() {
     CollectArgs  args;
     args.push_back("Arg1");
     args.push_back("Arg2");

     // create the raw view and have it destroyed immediately after this statement
     call(args.size(), args.raw_args());
   }

RAII char **用作exec参数向量

2 个答案: