C++ 字符數組向量

Question

我正在嘗試編寫一個具有字符數組向量的程序，但遇到了一些問題。

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

vector<char[]> v;

v.push_back(test);

抱歉，這必須是一個字符數組，因為我需要能夠生成字符列表，因為我正在嘗試獲得類似的輸出。

aaabacadaebabc

任何人都可以指出我正確的方向嗎？

謝謝

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)用於計算數組 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 回答，但仍需要一些解釋。 將數組包裝在一個類中將使向量數據滿足多維數組的要求。 C++ 11 和 upper 中的 STL 已經提供了這樣一個包裝器std::array 。
向量的向量適合許多目的，但不是答案，在某些情況下它只是錯誤的。 由於沒有清楚地理解數組和指針之間的區別，或者多維數組和數組數組之間的區別，因此陷入修復錯誤的陷阱是一種不愉快的經歷。 向量的向量包含向量作為元素：每個向量包含大小、容量、指向指向內存中隨機數據段的數據的指針的副本。 這些段不會像多維數組那樣一個接一個地放置。 這將導致與其他不支持C++ 向量的編程語言或庫的互操作性問題。
但是數組向量將始終指向一個連續的內存段，在一個地方以正確的順序包含多維數組的所有段。 從技術上講，數據指針將指向與多維數組相同的東西。 沒有充分的理由保持每個數組元素的大小，而已知所有元素的大小都相同。 至少它是多余的，但這不是什么大問題。 更大的問題是，它破壞了多維數組的結構。 這是與不支持C++ 向量的其他編程語言或庫的互操作性的另一個問題。
因此，可以通過將數組包裝在一個類中或使用現有的std::array來間接地制作數組向量。 它將在內存中存儲與二維數組相同的數據。 這種方法已經被許多圖書館廣泛使用。 在低級別，它將很容易與不支持 C++ 向量的 API 進行互操作。 所以不使用 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;
    //all the rest is uninitialised array
    v.push_back(a); // pushes to the end, with reallocation
    v.push_back(b); // pushes to the new end, 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;
}

在內存中它看起來非常可預測，十二個數組，兩個在開頭，兩個在結尾初始化，中間的其他八個未初始化，用零填充

C++11 和 upper 有std::array ，無需重新發明：

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

    //note, since size does not exceed capacity
    //this push_back will cause no reallocation and no relocation:
    v.push_back(array<int, 5>{ 7, 2, 53, 4, 5 });
    ///cin >> v[1][1];
    auto d = v.data();

現在，這就是向量的向量不是答案的原因。 假設以下代碼

int main()
{
    vector<vector<int>> vv = { { 1,2,3,4,5 }, { 9,8,7,6,5 } };
    auto dd = vv.data();
    return 0;
}

永遠猜不到數據在內存中是如何存儲的，絕對不是多維數組

Answer 7

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的使用。 對於字符緩沖， std::array<char,N>是最快的， std::vector<char>更快。

https://wandbox.org/permlink/wcasstoY56MWbHqd

Answer 8

我發現可以將 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;
}