C++ 如何在C++；？

我试图以最好的方式迭代静态字符串数组的所有元素。我希望能够在一行上声明它，并轻松地从中添加/删除元素，而无需跟踪数字。听起来很简单，不是吗

可能的非解决方案：

vector<string> v;
v.push_back("abc");
b.push_back("xyz");

for(int i = 0; i < v.size(); i++)
    cout << v[i] << endl;

问题-无法自动获取字符串数（据我所知）

必须有一个简单的方法来做到这一点

问题-无法自动获取字符串数（据我所知）

有一种bog标准的方法可以做到这一点，很多人（包括MS）定义宏，比如

arraysize

：

#define arraysize(ar)  (sizeof(ar) / sizeof(ar[0]))

下面是一个例子：

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

int main() {
    const char* const list[] = {"zip", "zam", "bam"};
    const size_t len = sizeof(list) / sizeof(list[0]);

    for (size_t i = 0; i < len; ++i)
        std::cout << list[i] << "\n";

    const std::vector<string> v(list, list + len);
    std::copy(v.begin(), v.end(), std::ostream_iterator<string>(std::cout, "\n"));
}

#包括
#包括
#包括
#包括
int main（）{
常量字符*常量列表[]={“zip”、“zam”、“bam”}；
const size_t len=sizeof（list）/sizeof（list[0]）；
对于（尺寸i=0；istd:：cout您可以从静态创建的
char*
数组简洁地初始化
向量
：

char* strarray[] = {"hey", "sup", "dogg"};
vector<string> strvector(strarray, strarray + 3);

char*strarray[]={“嘿”，“上”，“狗”}；
向量strvector（strarray，strarray+3）；

顺便说一句，这复制了所有的字符串，所以你使用了两倍的内存。你可以使用Will Dean的建议，用arraysize（str_数组）替换这里的魔法数字3——尽管我记得有一些特殊情况，在这种情况下，arraysize的特定版本可能会造成一些不好的结果（抱歉，我无法立即记住细节）.但它通常工作正常

另外，如果你真的很热衷于一行，你可以定义一个变量宏，这样一行，比如
define\u STR\u VEC（strvector，“hi”，“there”，“everybody”）；
就可以工作了

您可以使用Will Dean的建议[
#define arraysize（ar）（sizeof（ar）/sizeof（ar[0]））
]将这里的神奇数字3替换为arraysize（str_array）——尽管我记得在某些特殊情况下，特定版本的arraysize可能会做一些不好的事情（抱歉，我无法立即记住细节）.但它通常工作正常

当“数组”实际上只是一个指针而不是一个实际数组时，它就不起作用了。此外，由于数组传递给函数的方式（转换为指向第一个元素的指针），即使签名看起来像一个数组-
某个函数（字符串参数[]），它在函数调用中也不起作用
实际上是
一些函数（字符串*参数）
C++11添加了初始化列表，以允许以下语法：

std::vector<std::string> v = {"Hello", "World"};

std:：vector v={“你好”，“世界”}；

 C++至少11个特性的支持至少在.< /p> 中添加，而不是那个宏，我可以建议这个：
template<typename T, int N>
inline size_t array_size(T(&)[N])
{
    return N;
}

#define ARRAY_SIZE(X)   (sizeof(array_size(X)) ? (sizeof(X) / sizeof((X)[0])) : -1)

模板
内联大小\u t数组大小（t（&）[N]）
{
返回N；
}
#定义数组大小（X）（sizeof（数组大小（X））？（sizeof（X）/sizeof（X）[0]）：-1）

1） 我们希望使用宏使其成为编译时常量；函数调用的结果不是编译时常量

2） 但是，我们不想使用宏，因为宏可能会意外地用于指针。该函数只能用于编译时数组

因此，我们使用函数的定义属性使宏“安全”；如果函数存在（即，它的大小不为零），则我们如上所述使用宏。如果函数不存在，则返回错误值。
\35; include
#include <boost/foreach.hpp>

const char* list[] = {"abc", "xyz"};
BOOST_FOREACH(const char* str, list)
{
    cout << str << endl;
}

常量字符*列表[]={“abc”，“xyz”}；
BOOST_FOREACH（常量字符*str，列表）
{
cout一种可能性是使用空指针作为标志值：

const char *list[] = {"dog", "cat", NULL};
for (char **iList = list; *iList != NULL; ++iList)
{
    cout << *iList;
}

const char*list[]={“dog”，“cat”，NULL}；
for（char**iList=list；*iList！=NULL；++iList）
{
cout您可以使用Boost range库中的
begin
和
end
函数轻松找到基元数组的结尾，与宏解决方案不同，如果您意外地将其应用于指针，这将导致编译错误，而不是破坏行为

const char* array[] = { "cat", "dog", "horse" };
vector<string> vec(begin(array), end(array));

const char*数组[]={“猫”、“狗”、“马”}；
向量向量向量（开始（数组），结束（数组））；
#包括
#包括
#包括
#包括
int main（）
{
const std:：vectorv=boost:：assign:：list_of（“abc”）（“xyz”）；
复制(
v、 begin（），
v、 end（），
std:：ostream_迭代器（std:：cout，“\n”）；
}
< /Cord>
在C++中声明一组字符串，如：<代码> char ARRAYY OFSCONTRO[][]<代码> < /P>
例如：
char数组（由字符串[200][8192]组成）；

将容纳200个字符串，每个字符串的大小为8kb或8192字节

使用strcpy（行[i]，tempBuffer）；
将数据放入字符串数组。
您可以直接声明字符串数组，如
字符串s[100]；
。
然后，如果您想访问特定的元素，可以像
s[2][90]
那样直接获取它
s[i].size（）
函数。
FYI，字符串的字符数组[]不能接受C++字符串，首先要转换为char *。因为<代码> java字符串在一个头中，它不会违反一个定义规则吗？cha**究竟意味着什么？在Java中，它是字符串列表吗？@ DooSn奈特：在这种情况下，是的。在第一行中，我定义了一个数组：<代码> char */COD>。t作为3个指针-一个指向“dog”，一个指向“cat”，一个为空。我可以获取指向第一个指针的指针，并获得一个指向char**
-的指针。当我增加该值时，我将char**移动到列表中的下一项-指向“cat”的指针，然后我再次递增，得到一个指向空指针的指针，我知道我完成了。（或者，可以使用类似这样的方法：
模板内联大小\u t arraysize（t（&ar）[N]）{return N；}
（内联关键字不是必需的，但用于记录函数的意图。现代编译器理论上应该
const char* array[] = { "cat", "dog", "horse" };
vector<string> vec(begin(array), end(array));

#include <iostream>
#include <string>
#include <vector>
#include <boost/assign/list_of.hpp>

int main()
{
    const std::vector< std::string > v = boost::assign::list_of( "abc" )( "xyz" );
    std::copy(
        v.begin(),
        v.end(),
        std::ostream_iterator< std::string >( std::cout, "\n" ) );
}