RAII字符**用作exec参数向量

RAII char ** to be used as exec argument vector

本文关键字：参数 向量 exec 用作 字符 RAII      更新时间：2023-10-16

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

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()] = '';
   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())不起作用。。。

我通常分为两部分：

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

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

示例：

#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*函数族不遵循常量正确性，要么是因为std::string::data()没有非常量版本（C++17之前））。

或者，用这个类来很好地包装它：

#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());    
}
  • 将参数收集为常规字符串
  • 使用一个内部类：
    • 为指针的原始数组提供透明的隐式视图，以及
    • 同时负责管理这个指针数组

这个内部类的一个实例由某个访问方法返回。它的生存期跨越调用语句。参见以下示例：

   #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());
   }
相关文章：