char数组的C ++向量

Question

我正在尝试编写一个包含char数组向量的程序，但是我遇到了一些问题。

char test [] = { 'a', 'b', 'c', 'd', 'e' };

vector<char[]> v;

v.push_back(test);

对不起，这必须是一个char数组，因为我需要能够生成字符列表，因为我试图得到类似的输出。

a a b 一个c 广告 一个e b a b c

有人能指出我正确的方向吗？

由于

Answer 1

您无法在向量（或任何其他标准库容器）中存储数组。标准库容器存储的东西必须是可复制和可分配的，并且数组都不是这些。

如果你真的需要在一个向量中放置一个数组（你可能没有 - 使用向量向量或字符串向量更可能是你需要的），那么你可以将数组包装在一个结构中：

struct S {
  char a[10];
};

然后创建一个结构向量：

vector <S> v;
S s;
s.a[0] = 'x';
v.push_back( s );

Answer 2

你需要

char test[] = "abcde";  // This will add a terminating \0 character to the array
std::vector<std::string> v;
v.push_back(test);

如果您打算制作一个字符向量而不是字符串向量，

std::vector<char> v(test, test + sizeof(test)/sizeof(*test));

表达式sizeof(test)/sizeof(*test)用于计算数组测试中的元素数。

Answer 3

使用std::string代替char-arrays

std::string k ="abcde";
std::vector<std::string> v;
v.push_back(k);

Answer 4

您可以使用boost::array执行此操作：

boost::array<char, 5> test = {'a', 'b', 'c', 'd', 'e'};
std::vector<boost::array<char, 5> > v;
v.push_back(test);

修改

或者你可以使用矢量矢量，如下所示：

char test[] = {'a', 'b', 'c', 'd', 'e'};
std::vector<std::vector<char> > v;
v.push_back(std::vector<char>(test, test + sizeof(test)/ sizeof(test[0])));

Answer 5

您可以直接定义char类型向量，如下所示。

vector<char> c = {'a', 'b', 'c'};
vector < vector<char> > t = {{'a','a'}, 'b','b'};

Answer 6

实际上，从技术上讲，您可以将 C++ 数组存储在向量中，这很有意义。不是直接，而是通过一个简单的解决方法，包装在一个类中，将完全满足多维数组的所有要求。因为这个问题已经由 anon 回答了。钢铁需要一些解释。 STL 已经为这些目的提供了 std::array。
落入不明白数组和指针之间、多维数组和数组之间的区别的陷阱是一个令人不快的惊喜数组，等等。向量的向量包含向量作为元素。每个元素都包含大小、容量和其他内容的副本，同时元素的向量数据将被放置在内存中的不同随机位置。但是一个数组向量将包含一个包含所有数据的连续内存段，这与多维数组相同。此外，虽然已知所有元素的大小都相同，但没有充分理由保持每个数组元素的大小。 所以，做一个数组的向量，你不能直接做。但是您可以通过将数组包装在一个类中来轻松解决它，并且在此示例中，内存将与二维数组的内存相同。这种方法已经被许多图书馆广泛使用。在低级别，它将很容易与不支持 C++ 向量的 API 进行互操作。所以不使用 std::array 它将看起来像这样：

our_data %>% 
  ggplot(aes(date,crepus)) +
  geom_tile(aes(fill= nmb_individuals), height = 0.1)

由于 C++11 STL 包含 std::array 用于这些目的，因此无需重新发明它：

int main()
{
    struct ss
    {
        int a[5];
        int& operator[] (const int& i) { return a[i]; }
    } a{ 1,2,3,4,5 }, b{ 9,8,7,6,5 };

    vector<ss> v;
    v.resize(10);
    v[0] = a;
    v[1] = b;
    v.push_back(a); // will push to index 10, with reallocation
    v.push_back(b); // will push to index 11, with reallocation

    auto d = v.data();
    // cin >> v[1][3]; //input any element from stdin
    cout << "show two element: "<< v[1][2] <<":"<< v[1][3] << endl;
    return 0;
}

现在看看内存中的样子

现在，这就是向量的向量不是答案的原因。假设以下代码

....
#include<array>
....
int main()
{
    vector<array<int, 5>> v;
    v.reserve(10);
    v.resize(2);
    v[0] = array<int, 5> {1, 2, 3, 4, 5};
    v[1] = array<int, 5> {9, 8, 7, 6, 5};
    v.emplace_back(array<int, 5>{ 7, 2, 53, 4, 5 });
    ///cin >> v[1][1];
    auto d = v.data();

现在猜猜它在记忆中的样子

Answer 7

我发现将char *放入std :: vector：

是可以的

//  1 - A std::vector of char*, more preper way is to use a std::vector<std::vector<char>> or std::vector<std::string>
std::vector<char*> v(10, "hi!");    //  You cannot put standard library containers e.g. char[] into std::vector!
for (auto& i : v)
{
    //std::cout << i << std::endl;
    i = "New";
}
for (auto i : v)
{
    std::cout << i << std::endl;
}

Answer 8

FFWD到2019年。尽管此代码也将在2011年生效。

// g++ prog.cc -Wall -std=c++11
#include <iostream>
#include <vector>

 using namespace std;

 template<size_t N>
    inline 
      constexpr /* compile time */
      array<char,N> string_literal_to_array ( char const (&charrar)[N] )
 {
    return std::to_array( charrar) ;
 }

 template<size_t N>
    inline 
      /* run time */
      vector<char> string_literal_to_vector ( char const (&charrar)[N] )
 {
    return { charrar, charrar + N };
 }


int main()
{
   constexpr auto arr = string_literal_to_array("Compile Time");
   auto cv = string_literal_to_vector ("Run Time") ;
   return 42;
}

建议：尝试优化std::string的使用。对于char缓冲，std::array<char,N>最快，std::vector<char>更快。

https://wandbox.org/permlink/wcasstoY56MWbHqd