数组不能存储在向量中（或任何其他标准库容器中）。标准库容器存储的内容必须是可复制和可赋值的，而数组两者都不是。
如果你真的需要把数组放到一个向量中（你可能不需要--使用向量的向量或者字符串的向量更有可能是你需要的），那么你可以把数组 Package 在一个结构体中：

struct S {
  char a[10];
};

然后创建一个结构体向量：

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

你需要

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)用于计算数组测试中的元素数。

使用std::string代替字符数组

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

您可以使用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])));

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

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

事实上，从技术上讲，你可以将C数组存储在一个向量中，不是直接地，而是通过一个简单的解决方案。这很有意义。问题已经被Anon回答了，但是仍然需要一些解释。将数组 Package 在一个类中将使向量数据满足多维数组的要求。C 11和更高版本的STL已经提供了这样的 Package 器std::array。
向量的向量适用于许多用途，但不是答案，在某些情况下，它就是错误的。由于不清楚数组和指针之间的区别，或多维数组和数组的数组之间的区别，陷入修复错误的陷阱是一种不愉快的经历。向量的向量包含向量作为元素：每个都包含大小、容量、指向内存中随机数据段的数据指针的副本。2这些数据段不会像多维数组一样一个接一个地放置。3这将导致与其他编程语言或库的互操作性问题，因为它们不支持C++ vector。
但是数组的向量总是指向内存的一个连续段，在一个地方以正确的顺序包含多维数组的所有段。从技术上讲，数据指针将指向与多维数组相同的东西。没有很好的理由保持每个数组元素的大小，而已知它对所有元素都是相同的。至少它是冗余的。但这并不是什么大问题，更大的问题是，它破坏了多维数组的结构。
因此，创建数组的向量可以间接完成，通过将数组 Package 在类中或使用现有的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;
}

在内存中，它看起来很容易预测，12个数组，两个在开头，两个在结尾，初始化了，另外8个在中间，未初始化，用零填充

C++11及更高版本有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;
}

数据是如何存储在内存中的永远无法猜测，它肯定不是一个多维数组

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

下面是如何从C样式字符串或std：：string或C++中的字符数组初始化字符的std：：vector：

size_t count_O(const std::vector<char>& vectStr)
    {
        size_t counter{ 0 };
        for (const auto& item : vectStr)
        {
            std::cout << item << '\n';
            if (item == 'o')
                ++counter;
        }
        return counter;
    }

 

 int main()
{
    
    
    //1
    std::vector<char> vectCharA = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!' };
    std::cout << "count: " << count_O(vectCharA) << '\n';

    //2
    const char* str1 = "Hello World!";
    const size_t len = strlen(str1);
    std::vector<char> vectCharB(str1, str1 + len);
    std::cout << "count: " << count_O(vectCharB) << '\n';

    //3
    char arrtChar[] = "Hello World!";
    std::vector<char> vectCharC(arrtChar, arrtChar + sizeof(arrtChar) / sizeof(*arrtChar));
    std::cout << "count: " << count_O(vectCharC) << '\n';

    //4
    std::string str2 = "Hello World!";
    std::vector<char> vectCharD(str2.begin(), str2.end());
    std::cout << "count: " << count_O(vectCharD) << '\n';

    //5
    std::string str3 = "Hello World!";
    std::vector<char> vectCharE(std::begin(str3), std::end(str3));
    std::cout << "count: " << count_O(vectCharE) << '\n';
 return 0;
}

我发现可以将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;
}