C++ 我可以使用std:：string*argv作为主函数参数吗？

通常我看到：

int main(int argc, char** argv)

但我可以使用：

int main(int argc, std::string* argv)

相反

如果无法将

char*

转换为

std:：string

---

PS：我正在使用C++11

不，你不能。但是，您可以使用类似以下内容将它们存储为

std:：string

s

#include <iostream>
#include <string>
#include <vector>

int main(int argc,char** argv){
    std::vector<std::string> strings(argc-1);
    for(size_t i{}; i < strings.size();++i){
        strings[i] = std::string{argv[i+1]};
    }
    for(const auto& el :strings)
        std::cout << el << " ";


    return 0;
}

#包括
#包括
#包括
int main（int argc，字符**argv）{
std：：向量字符串（argc-1）；
对于（size_t i{}；istd:：cout
main
参数必须是
char**argv
或
char*argv[]


2.实现不应预定义
主功能。
此功能不应过载。
它的类型应该有C++语言链接，它应该有一个声明类型的返回类型<代码> int >代码>，但否则它的类型是实现定义。
一项实施应允许两者兼而有之

（2.1）。
返回
int
和
的函数

（2.2）。
返回
int
的
（int，指向char的指针）
函数


您可以使用以下方法之一转换代码中的参数：

int main(const some_container<const some_string_type> args){
  for (auto Arg : args) {
    // some usage of this character array...
  }
}


简单地分配它：


使用参数作为构造函数参数构造字符串：


使用初始值设定项列表：


如果您想保留一组参数，我建议您使用以下方法之一将它们保存在一个可变大小的容器
std:：vector
：

int main(const some_container<const some_string_type> args){
  for (auto Arg : args) {
    // some usage of this character array...
  }
}


使用
std:：vector
构造函数就地构造向量，此处使用指向字符串数组
argv
开头和结尾的指针作为构造函数参数：

std:：向量strs（&argv[1]，&argv[argc]）//*


使用初始值设定项列表：

std:：vector strs{&argv[1]，&argv[argc]}//*


在循环中添加参数：

std:：向量strs；
对于（int i=1；i

*不包括
argv[0]
程序名。
否，但标准委员会对此进行了一些讨论
在论文中，Erich Keane建议让标准考虑以下内容：

int main(const some_container<const some_string_type> args){
  for (auto Arg : args) {
    // some usage of this character array...
  }
}

int main（const some_容器参数）{
用于（自动参数：参数）{
//此字符数组的某些用法。。。
}
}

问题是应该使用哪个容器和哪个字符串类型。基恩先生建议使用
字符串视图的
初始值设定项列表
，而不是
std:：string
，因为后者需要大量资源，而's'则非常轻量级。
不，但您可以通过使用带迭代器的
向量
来创建
std:：vector
：

template< class InputIt >
vector( InputIt first, InputIt last, const Allocator& alloc = Allocator());

要将普通的
main
与增强的
main
分开，您可以这样做：

#include <iostream>
#include <string>
#include <vector>

int cppmain(std::string program, std::vector<std::string> args) {
    std::cout << program << " got " << args.size() << " argument(s):\n";

    for(auto& arg : args) { // each argument as a string
        std::cout << " " << arg << '\n';
    }
    return 0;
}

int main(int argc, char* argv[]) {
    //
    //         string from char*
    //                |
    //                V
    return cppmain(argv[0], {argv + 1, argv + argc});
    //                      ^                     ^
    //                      |                     |
    //                     vector<string> from char*[]
}

#包括
#包括
#包括
int cppmain（std:：string程序，std:：vector args）{
std：：cout什么是
size\ut i{}
意思？@klutt它是统一值初始化。@klutt它声明了一个名为
i
的变量，其类型为
size\ut
，并通过
{}
对其进行初始化，也就是说-with
0
。那么基本上就是
size\ut i=0
？
    std::vector<std::string> strs;

    for(int i = 1; i < argc; i++) //*
        strs.push_back(argv[i]);   
    }

int main(const some_container<const some_string_type> args){
  for (auto Arg : args) {
    // some usage of this character array...
  }
}

template< class InputIt >
vector( InputIt first, InputIt last, const Allocator& alloc = Allocator());

std::vector<std::string> args(argv + 1, argv + argc);

#include <iostream>
#include <string>
#include <vector>

int cppmain(std::string program, std::vector<std::string> args) {
    std::cout << program << " got " << args.size() << " argument(s):\n";

    for(auto& arg : args) { // each argument as a string
        std::cout << " " << arg << '\n';
    }
    return 0;
}

int main(int argc, char* argv[]) {
    //
    //         string from char*
    //                |
    //                V
    return cppmain(argv[0], {argv + 1, argv + argc});
    //                      ^                     ^
    //                      |                     |
    //                     vector<string> from char*[]
}