使用 forrange 循环打印 argv

Question

int main(int argc, const char** argv) {

    std::cout << "Hello" << std::endl;

    char arr2d[][4] = {"ABC", "DEF"};

    for (char *i : arr2d)
    {
        std::cout << i << std::endl;
    }

在这里，我将 forrange 的工作评估为：“对于arr2d 中的每个字符数组，将其打印到控制台”。这是有效的，所以，至少我的理解应该是正确的。上面代码sn-p的输出是，

muyustan@mint:~/Desktop/C_Files/oop$ g++ main.cpp -o main && ./main
Hello
ABC
DEF

正如预期的那样。

但是，如果我尝试这个，

int main(int argc, const char** argv) {

    std::cout << "Hello" << std::endl;

    char arr2d[][4] = {"ABC", "DEF"};

    for (const char *i : argv)
    {
        std::cout << i << std::endl;
    }

首先 IDE 会警告我，

这个基于范围的“for”语句需要一个合适的“begin”函数，但没有找到

如果我尝试编译，我会得到：

muyustan@mint:~/Desktop/C_Files/oop$ g++ main.cpp -o main && ./main
main.cpp: In function ‘int main(int, const char**)’:
main.cpp:30:26: error: ‘begin’ was not declared in this scope
     for (const char *i : argv)
                          ^~~~
main.cpp:30:26: note: suggested alternative:
In file included from /usr/include/c++/7/string:51:0,
                 from /usr/include/c++/7/bits/locale_classes.h:40,
                 from /usr/include/c++/7/bits/ios_base.h:41,
                 from /usr/include/c++/7/ios:42,
                 from /usr/include/c++/7/ostream:38,
                 from /usr/include/c++/7/iostream:39,
                 from main.cpp:1:
/usr/include/c++/7/bits/range_access.h:105:37: note:   ‘std::begin’
   template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
                                     ^~~~~
main.cpp:30:26: error: ‘end’ was not declared in this scope
     for (const char *i : argv)
                          ^~~~
main.cpp:30:26: note: suggested alternative:
In file included from /usr/include/c++/7/string:51:0,
                 from /usr/include/c++/7/bits/locale_classes.h:40,
                 from /usr/include/c++/7/bits/ios_base.h:41,
                 from /usr/include/c++/7/ios:42,
                 from /usr/include/c++/7/ostream:38,
                 from /usr/include/c++/7/iostream:39,
                 from main.cpp:1:
/usr/include/c++/7/bits/range_access.h:107:37: note:   ‘std::end’
   template<typename _Tp> const _Tp* end(const valarray<_Tp>&);

那么，为什么 argv 的行为与我的 arr2d[][4] 不同？不都是char指针(char数组还是字符串(?))的指针吗？

如果我的理解有问题，使用 forrange 打印 argv 的成分应该是什么结构？

Answer 1

这是我被告知错误的事情，当时我在处理 C 时，在某个地方我读到“数组也是指针！”。

关于该声明，有几点必须理解。

1. 在大多数情况下，数组衰减为指针，但数组仍然不同于指针。

   • 当用作sizeof的参数时，以下两个将导致不同的答案。

     char const* ptr = "Some text.";
     char array[] = "some text.";
     
     std::cout << sizeof(ptr) << std::endl;    // prints sizeof the pointer.
     std::cout << sizeof(array) << std::endl;  // prints sizeof the array.
     

   • 用作addressof 运算符的参数时。

     char const* ptr1 = "Some text.";
     char array[] = "some text.";
     
     char const** ptr2 = &ptr1;      // OK.
     char** ptr3 = &array;           // Error. Type mismatch.
     char (*ptr4}[11] = &array;      // OK.
     

2. 二维数组可以衰减为指向一维数组的指针，但不会衰减为指向指针的指针。

    int array1[10];
    int* ptr1 = array1;          // OK. Array decays to a pointer
   
   
    int array2[10][20];
    int (*ptr2)[20] = array2;    // OK. 2D array decays to a pointer to 1D array.
    int**  ptr3 = array2;        // Error. 2D array does not decay to a pointer to a pointer.
   

Answer 2

它们的行为不同，因为它们有不同的类型。这让初学者感到困惑，但是：

char **

是指向char 的指针。实际上，在argv 的情况下，它指向一个指针序列，每个指针都指向一个以 nul 结尾的字符串（它们是字符序列）。

迭代这些的问题是这些序列的大小是未知的。编译器无法知道argc 与上述第一个序列有关。

但是：

char arr2d[][4] = {"ABC", "DEF"};

解析为类型：

char [2][4]

这是char的数组数组。在这种情况下，大小是已知的 (2)，因此您可以对其进行迭代。

最后，编译器抱怨std::begin，因为基于范围的for循环被转换成不同的等效代码，使用std::begin等来进行迭代。

Answer 3

如果您想将基于范围的for 应用到argv，首先创建一个包含参数的向量可能是最简单的：

#include <iostream>
#include <vector>

int main(int argc, char **argv){ 
    std::vector<std::string> args(argv, argv+argc);

    for (auto const &arg : args) {
        std::cout << arg << "\n"; // don't use `endl`.
    }
}

就argv 而言，与二维数组相比，区别相当简单。当你有一个数组声明时，数组可以通过引用模板来传递，模板可以计算出它的大小：

template <class T, size_t N>
size_t array_size(T (&array)[N]) {
    return N;
}

int foo[2][3];
std::cout << array_size(foo) << "\n";

char bar[12][13][14];
std::cout << array_size(bar) << "\n";

...但是，argv 没有这样的静态可见定义，编译器可以从中推断出它的大小。在典型情况下，在main 之外运行的代码会检查命令行并动态分配它。

Answer 4

range-for 表达式适用于迭代器（指针是一种迭代器），它需要一个指向范围开头和结尾的迭代器。它通过将范围传递给std::begin 和std::end 来获得这些。

arr2d 的类型是char[2][4]。作为一个数组，它携带有关其大小的信息作为其类型的一部分。 std::begin 和 std::end 有模板重载，它们分别接受对数组的引用并返回指向其第一个和最后一个元素的指针。

argv 的类型是char**。它只是一个指向char 的指针。编译器不知道这些指针中的任何一个指向数组的第一个元素，并且这些指针不携带有关它们指向的数组长度的信息。因此，没有接受指针的std::begin 和std::end 的重载，因为std::end 无法仅从指针确定数组的末尾相对于开头的位置。

要使用范围为的指针，您必须提供有关数组长度的信息。在这种情况下，您可以在数组上构造一个简单的视图，因为您从 argc 知道它的长度：

template <typename T>
class PointerRange
{
private:
    T* ptr_;
    std::size_t length_;

public:
    PointerRange(T* ptr, std::size_t length)
        : ptr_{ptr},
          length_{length}
    {
    }

    T* begin() const { return ptr_; }
    T* end() const { return ptr_ + length_; }
};

int main(int argc, char** argv)
{
    for (char* arg : PointerRange(argv, argc)) {
        std::cout << arg << "\n";
    }
}

Live Demo

一旦 C++20 可用，std::span 可以代替上面定义的 PointerRange：

int main(int argc, char** argv)
{
    for (std::string_view arg : std::span{argv, argc}) {
        std::cout << arg << "\n";
    }
}

Answer 5

如果你的编译器有 span 头文件（现在不是很多），我想这会起作用。

// Example program
#include <iostream>
#include <string_view>
#include <span>

int main(int argc, char **argv)
{
  for (std::string_view s : std::span{argv, argc})
  {
      std::cout << s << std::endl;
  }
  return 0;
}

我的示例的唯一开销是让 string_view 找到空终端。我试过 goldbolt.org 但似乎没有一个编译器可以找到 span 头文件。所以请轻视我的建议。