为什么我必须为std::array分配一个大小，而普通数组不一定是这样的？
std::array是C++标准库中的一个容器类，用于存储固定大小的数组。与普通数组相比，std::array需要在编译时指定其大小，而普通数组可以在运行时动态分配大小。
这是因为std::array是一个封装了固定大小数组的类模板，它的大小是在编译时确定的，因此需要在声明时指定大小。这样做的好处是可以在编译时进行类型检查和优化，提高代码的安全性和效率。
另一方面，普通数组是一种原生的数据类型，可以在运行时动态分配大小。这种动态分配的灵活性使得普通数组可以根据实际需求进行大小的调整，但也带来了一些潜在的问题，比如内存泄漏和越界访问等。
对于std::array的应用场景，它适用于需要在编译时确定大小的场景，比如在函数中传递固定大小的数组参数、存储一组固定大小的数据等。在使用std::array时，可以通过使用其成员函数size()来获取数组的大小。
腾讯云提供了一系列与云计算相关的产品，其中包括云服务器、云数据库、云存储等。具体可以参考腾讯云官方文档：https://cloud.tencent.com/document/product/213
注意：本回答仅供参考，具体产品选择还需根据实际需求和情况进行评估。
相关·内容
2回答
定义多维std数组时，内存布局是什么？
它是单个连续内存块还是指针数组？
例如-
const size_t M = 5;
const size_t N = 4;
int simple_2D_array[M][N];
std::array<std::array<int,N>,M> std_2D_array;
它是否保证simple_2D_array和std_2D_array将具有与单个连续内存相同的内存布局？
浏览 2提问于2021-12-23得票数 0
回答已采纳
为什么创建一个大于内存的一维数组失败，但是我可以创建一个大于内存的二维数组？我认为操作系统给了你虚拟内存，你可以想要多少就请求多少。直到你开始对内存进行读写，并且它成为驻留集的一部分，硬件约束才会成为一个问题。
在内存为512MB的小型虚拟机上，我尝试了：
1, 512 MB array: no issue
1, 768 MB array: no issue
1, 879 MB array: no issue
1, 880 MB array: fails
1, 1024 MB array: fails
1000, 512MB arrays no issue (at this point
浏览 9提问于2018-07-28得票数 2
我在sizeof(std::vector<T>)和sizeof(std::array<T, N>)之间感到困惑。
int main(int argc, char const *argv[]) {
std::vector<int64_t> vec_1(2);
std::cout << sizeof(vec_1) << std::endl; // 24
std::vector<int64_t> vec_2(5);
std::cout << sizeof(vec_2) <&l
浏览 7提问于2022-03-12得票数 0
5回答
我想和std::array混在一起，看看它和std::vector有多大的不同。到目前为止，我只发现了一个主要的区别。
Sentence sentence = { "Hello", "from", "GCC", __VERSION__, "!" };
std::array<std::string, 10> a;
std::copy(sentence.begin(), sentence.end(), a.begin());
int i = 0;
for (const auto& e : a)
{
i
浏览 6提问于2013-05-05得票数 3
回答已采纳
我尝试在java中使用整数数组，代码如下：
public static void main(String[] args) {
int[] array = testArray(100);
System.out.println(array.length);
for(int i = 0; i < 100; i++)
System.out.println(array[i]);
}
public static int[] testArray(int size){
int[] array
浏览 0提问于2012-03-28得票数 0
回答已采纳
我有一个基类，它包含数组并提供一个简单的operator[]：
class Object
{
public:
std::shared_ptr<Object> operator[](const int index);
[...]
private:
std::vector<std::shared_ptr<Object>> internal_array;
};
当我想直接访问操作符而不取消引用时，我的编译器(MSVC 2017)不喜欢这样：
std::shared_ptr<Object> one_object;
std::s
浏览 0提问于2018-01-21得票数 0
回答已采纳
3回答
在阅读C++初级读物时，我看到了这样的说法：“数组中元素的数量是数组类型的一部分。”因此，我想使用以下代码来找出答案：
#include<iostream>
int main()
{
char Array1[]{'H', 'e', 'l', 'p'};
char Array2[]{'P', 'l', 'e', 'a', 's', 'e'};
std::cout<<typeid(Arra
浏览 4提问于2019-11-21得票数 14
回答已采纳
c++11使用模板定义数组的max_size (例如，std::array<int, 5> a1;)，但不是构造函数。(例如，std::array<int>(5) a1;)
由于模板将为类生成代码，并且如果我有许多大小不同的数组，那么将有大量代码需要生成。
(1 )可能会导致编译时间增加。2.可能会导致可执行文件的代码部分扩展。)
浏览 2提问于2012-11-30得票数 2
回答已采纳
4回答
使用std：：数组创建树
、、、、
底部的代码会生成以下编译时错误。如果我使用std::vector<Node>或std::array<unique_ptr<Node>, 3>，错误就会消失。谁能解释一下这是怎么回事吗？
在main.cpp:1:0: /usr/include/c++/4.9/array中包含的文件:在‘struct：：array’：main.cpp:9:23的实例化中：
需要从此处/usr/include/c++/4.9/array:97:56: error：‘std：：array<_Tp，_Nm>：：_M_elems’具有不完全类型的_AT_Type::_Ty
浏览 0提问于2014-12-30得票数 5
回答已采纳
我试图在C中再现std::vector的行为，我有一些想法:向量有一个连续分配的内存，这意味着当您在末尾添加一个元素时，它不会将所有数组复制到另一个内存块，而是只在最后分配另一个元素，这会提高性能，但在C中，我无法找到再现该行为的方法，在最后添加元素的唯一方法是这样做：
void *new_array;
size_t new_size = old_size + size_type;
new_array = (char*)malloc(size_type * new_size);
memcpy(new_array, old_array, old_size * size_type);
memcpy
浏览 10提问于2021-04-06得票数 0
回答已采纳
我看到了许多建议使用智能指针在内存中保存动态分配数组的答案。我的观点一直是，如果已知大小，它应该包装在std::array中；同样，如果不知道大小(即，通过使智能指针的指针类型成为未知绑定的数组，并在以后对其进行reset()‘处理)，则应该使用std::vector。事实上，这就是我经常做的事情。
例如，最近我看到了一个使用std::unique_ptr<int[5]> p(new int[5])的答案。这似乎类似于构造一个std::array<int, 5>，因为它的大小是已知的。此外，附加的好处是std::array静态地分配其数组并包含类似数组的特性，如大小、迭
浏览 8提问于2014-09-06得票数 9
回答已采纳
2回答
我在这里阅读了C++中数组对象的文档：和我看到模板头是
template<
class T,
std::size_t N
> struct array;
为什么N是作为非类型参数传递的，而不是具有以大小作为变量的构造函数的结构？
当模板的全部要点被用于泛型类型时，非类型参数的用途是什么？
浏览 1提问于2020-08-01得票数 3
回答已采纳
1回答
有这样一种类型的std::size_t。它可以用于描述对象的大小，因为它保证能够表示任何对象的最大大小(因此编写了)。但这意味着什么呢？我们实际上没有记忆中的物体。那么，这是否意味着这种类型可以存储一个整数，它代表我们理论上可以使用的最大内存量？
如果我试着写这样的东西
size_t maxSize = std::numeric_limits<std::size_t>::max();
new char[maxSize];
我将得到一个错误，因为数组的总大小限制在0x7fffffff。为什么？此外，如果传递一个等于maxSize的非常数表达式，则会抛出std::bad_array_n
浏览 3提问于2017-09-11得票数 6
回答已采纳
2回答
为什么下面的代码在用gcc编译时运行得很好，而用clang (3.4)编译时却有段错误。如果删除明显多余的Thread对象，则代码运行良好。另外，如果使任何数组变得更小，代码也会运行得很好。
#include <array>
#include <emmintrin.h>
class Thread {
public:
std::array<__m128i, 16 * 3 * 3 * 1280> m_BlockTypes;
unsigned int m_SeedIdx1[16 * 16 * 3 * 3 * 512];
};
class B
浏览 2提问于2014-06-02得票数 3
回答已采纳
让我们拥有，
std::array <int,5> STDarr;
std::vector <int> VEC(5);
int RAWarr[5];
我试着弄清楚它们的大小，
std::cout << sizeof(STDarr) + sizeof(int) * STDarr.max_size() << std::endl;
std::cout << sizeof(VEC) + sizeof(int) * VEC.capacity() << std::endl;
std::cout << sizeof(RAWa
浏览 2提问于2012-01-08得票数 2
回答已采纳
有人能解释为什么在C++中声明动态2D数组时使用指向指针(**)的指针吗？我不明白为什么我们要用循环。
using namespace std;
int main(){
int **matrixPtr;//2d array declaretion
cout << "enter no of rows: ";
int row;//defining row
cin >> row;//initializing value of row from user
cout << "enter no of c
浏览 0提问于2020-08-31得票数 0
回答已采纳
1回答
C++类对象的总内存
、、、
为什么下面的代码给出24作为一个答案？也就是说，以下类X的对象的总大小是24字节？我用的是64位机。
#include <bits/stdc++.h>
using namespace std;
class X
{
vector <bool> f;
int b;
public:
X(){
f.push_back(true);
}
};
int main(){
X ob;
cout<<sizeof(ob);
return 0;
}
浏览 3提问于2015-10-04得票数 1
回答已采纳
对于我的项目，我需要将指向ComplicatedClass类型对象的指针存储在数组中。这个数组与我在这里省略的其他信息一起存储在一个类Storage中。
下面是我想要做的事情(这显然不起作用，但希望能解释我正在努力实现的目标)：
class ComplicatedClass
{
...
}
class Storage
{
public:
Storage(const size_t& numberOfObjects, const std::array<ComplicatedClass *, numberOfObjects>& obje
浏览 2提问于2021-12-21得票数 1
回答已采纳
请原谅我的无知，在我看来，std::array是用来替换常规数组的。但是，由于数组大小必须作为模板参数传递，因此它阻止我们创建一个只有在运行时才知道的大小的std::array。
std::array<char,3> nums {1,2,3}; // Works.
constexpr size_t size = 3;
std::array<char,size> nums {1,2,3}; // Works.
const buf_size = GetSize();
std::array<char, buf_size> nums; // Doesn'
浏览 8提问于2020-02-15得票数 7
回答已采纳
众所周知，在实验C++：中有事务内存TS (ISO/IEC 19841:2015)。
operator[]声明为transaction_safe只适用于容器：std::vector，std::unordered_map，std::unordered_multimap，std::unordered_set，std::unordered_multiset，std::deque -从n4514：获得
23.4联想容器
23.4.4类模板地图
23.4.4.1类模板地图概述map.overview
在23.4.4.1 map.overview中，将"transaction_safe“添加到b
浏览 4提问于2016-08-03得票数 3
回答已采纳
3回答
我将变量arrSize赋值为零( int arrSize = 0; )，在下一行中，我从用户那里获取变量arrSize的输入。假设用户将5 value赋值给变量。
当我执行我的代码时，Cin只接受4 values而不是5。
但是，当我只声明变量( int arrSize; )而没有给它赋值时，它工作得很好。
我是个新手，你能解释一下为什么会这样吗？
谢谢!
下面是我的代码：
#include <iostream>
using namespace std;
int main(){
int arrSize = 0;
int arr[arrSize];
浏览 4提问于2021-04-02得票数 1
4回答
使用'new‘如何被认为是动态的？我知道它会被放到堆上，返回一个指针并停留在那里，但我还没有意识到它在分配方面的“动态”性质。
在下面的情况下，两个数组都是在运行时分配的，甚至是静态方法。所以我看不出有什么不同。两者都有，我认为不可能动态地增加/缩小分配，对吗？
int size = 0;
std::cout << "enter size: ";
std::cin >> size;
int* array_d = new int[size]; // "dynamic" allocation
int array_s[size];
浏览 2提问于2013-07-09得票数 2
回答已采纳
3回答
二维数组的动态内存分配
、、、
我想为一个2D数组动态分配内存。
这两者之间有什么区别吗？
1)
array = (int**)malloc(size * sizeof(int*));
for (i = 0; i < size; i++) {
array[i] = (int *) malloc(size * sizeof(int));
}
2)
array = (int**)malloc(size *size* sizeof(int));
如果是，使用哪个更好?为什么？
浏览 1提问于2014-07-28得票数 0
为什么sizeof操作符产生12个字节，而它应该只有4个字节？当我引用变量array时，它只引用数组的第一个索引的内存地址。实际上，我打印了第一个索引&array[0]的内存地址，并将其与array进行了比较，它们产生了相同的内存地址结果，这证实了它们都引用了数组的第一个索引，但是“数组”生成12字节，而array[0]生成4字节。
int main() {
int array[] = {1,2,3};
int a = 1;
int b = sizeof(array); //this is referring to the first index of the array
int c
浏览 6提问于2021-04-16得票数 2
回答已采纳
7回答
我想使用boost::array作为类成员，但我不知道编译时的大小。我想到了这样的东西，但它不起作用：
int main() {
boost::array<int, 4> array = {{1,2,3,4}};
MyClass obj(array);
}
class MyClass {
private:
boost::array<int, std::size_t> array;
public:
template<std::size_t N> MyClass(boost::array<i
浏览 0提问于2010-01-09得票数 17
回答已采纳
4回答
在下面的代码中，编译器抱怨为：struct std::array<double,5ul> has no member named 'assign'。，这似乎是可能的。为什么会这样呢？(编译器: g++ 4.8.2)
#include <array>
int main()
{
std::array<double,5> arr;
arr.assign(4.); // error: has no member named 'assign'
return 0;
}
浏览 0提问于2014-06-17得票数 4
回答已采纳
我正在使用C++中的数组。我定义了一个名为矩阵的2d数组，并将提取负值并将其赋值给名为数组的数组。
是否有一种方法可以快速地将数组初始化为零，而不是枚举所有元素？我查看了其他帖子和行，例如：int array[10] = {}或int array[10] = {0}不适用于我的编译器。如果我尝试使用这些语句，就会得到错误消息error: variable-sized object ‘array’ may not be initialized。
我的课本上说，所有数组在声明时都初始化为零，但我在编译器上测试了这一点，这不是真的；我不得不使用for-循环将其强制为零。有正确的方法吗？
哦，顺便说一
浏览 0提问于2013-11-08得票数 3
回答已采纳
我不能在Float32Array上使用.push()，我得到了一个错误，所以我尝试这样添加它：
myarray = new Float32Array() ;
myarray.push = function()
{
for( var i in arguments )
{
this[this.length] = arguments[i] ;
}
} ;
但它不起作用。我没有得到错误，但是我的数组的值都是0。为什么？
浏览 2提问于2014-06-25得票数 14
回答已采纳
5回答
数组声明和大小初始化(C++)
、、、、
我不太确定如何提出这个问题，所以我将从一些示例代码开始：
//header file
class A
{
public:
A();
private:
int x;
std::string arr[x];
}
//cpp file
class A
{
public:
A()
{
/*code to get the value of x from a cmd call*/
}
}
此代码有效吗？更具体地说，我可以让我的头文件中的字符串数组的大小为x吗，即使在创建A对象之前x没有明确的赋值？
如果这不起作用，我唯一的其他选择是使用动态分配
浏览 0提问于2012-08-01得票数 1
回答已采纳
5回答
C++阵列的存储效率
、、、
在我脑干的某个地方，一个声音低语着：
在C++中，数组不需要比元素数量更多的内存。
std::string str = "aabbcc";
std::array<std::string, 3> str_array = {"aa", "bb", "cc"};
因此，两者应该具有相同的大小，因为(与Java不同)没有单独的size字段或类似的字段。但我还没找到推荐信。
这是真的吗？在什么情况下不是呢？
浏览 1提问于2018-02-27得票数 1
回答已采纳
我会检测我想要写的索引是否超出了容量，如果是这样的话，我会调整它的大小以适应新的索引。我立即调用myVector.at( iIx )= newValue，需要做些什么来重置向量吗？它在第一次调整大小之后工作，但在第二次调整之后就不能工作了。我希望有一种值得尊敬的标准来解决这个问题，而不是需要几天的研究。几年前，我写了我自己的可调整大小数组，我想我很快就会回到那个代码。
下面是代码，它对第一次调整大小是正确的。
if ( iIx >= iCapacity ) { // need to resize
iAddNeeded = miMallocSiz
浏览 7提问于2022-11-07得票数 0
5回答
结构末尾的大小为0的数组
、、、、
我正在上的一门系统编程课程的教授今天告诉我们，在最后定义一个带有零长度数组的结构：
struct array{
size_t size;
int data[0];
};
typedef struct array array;
这是一个有用的结构，用于定义或初始化具有变量的数组，即如下所示：
array *array_new(size_t size){
array* a = malloc(sizeof(array) + size * sizeof(int));
if(a){
a->size = size;
}
retur
浏览 7提问于2016-04-12得票数 39
我试着写这段代码，但它显示表达式的值不是常量。我了解到这是因为VS不允许未声明的数组，因为VS不能理解"n“。如何使用声明的数组修复此代码？
#include<iostream>
using namespace std;
int main()
{
int i, n;
cout << "Enter size of array:";
cin >> n;
int a[n];
cout << "Enter elements of array:" << end
浏览 0提问于2020-05-12得票数 0
下面是一个MergeSort实现。我的问题是编译器抱怨不能将std::begin应用于可变大小的数组temp以进一步使用std:copy。
我用的是C++17和gcc 8.3。
template<typename Container, typename Iterator>
void Search::MergeSort(Container &array, Iterator begin, Iterator end)
{
auto const len = end - begin;
if (len > 1)
{
auto mid = b
浏览 1提问于2019-04-26得票数 4
回答已采纳
1回答
我知道我可以有任何类型的for循环来迭代：
#include <fstream>
#include <iostream>
using namespace std;
int main()
{
int ar[] ={ 1, 2, 3 };
for (int i:ar)
{
cout << i << endl;
}
}
但是我不能有指针类型：
#include <fstream>
#include <iostream>
#include <string>
usin
浏览 2提问于2020-08-05得票数 0
回答已采纳
为什么这是一个错误：
typedef int H[4];
H * h = new H; // error: cannot convert 'int*' to 'int (*)[4]' in initialization
此外，为什么这不是一个错误：
H * h = new H[1];
为什么编译器认为new H返回int *，而new H[1]按预期返回H *？
换句话说:为什么T * t = new T; T 对于一般类型T是正确的，但是当T是数组类型时却是不正确的？
通过new分配简单数组类型的规范方法是什么？
请注意，这是一个简化的示例
浏览 3提问于2016-05-13得票数 17
回答已采纳
为什么允许这样做：
// 1
struct S {
std::vector<S> v;
};
// 2
struct T {
T* ptr;
};
而这并不是：
// 3
struct X {
X arr[];
};
下面是第三个示例(clang-1001.0.46.3编译器)的错误：
sample.cpp:9:4: error: field has incomplete type 'X'
X arr[];
^
sample.cpp:8:8: note: definition of 'X'
浏览 0提问于2019-07-13得票数 1
回答已采纳
在堆栈上分配时，我不一定需要知道编译时分配的C数组的大小。也就是说，我可以这样做：
void foo(size_t s) {
uint8_t bar[s]; // `s` not known at compile time
some_func_that_uses_bar(bar, sizeof(bar));
}
然而，为了减少错误的发生，我觉得我也应该能够用C++ std::array来完成这个任务，但是我还没有弄清楚如何做到(甚至可能)。
浏览 0提问于2019-08-02得票数 2
回答已采纳
2回答
我在C中实现了插入排序，帮助我的人告诉我的东西是一个指针，如下面的一行所示，但是为什么呢？
size_t size = sizeof( array ) / sizeof( *array );
为什么第二个是指向数组的指针，size_t是做什么的？
浏览 4提问于2014-07-09得票数 0
回答已采纳
3回答
void Merge(int *array, int lo, int mid, int hi) {
int tArray[20];
int loBeg = lo;
int count = lo;
int hiBeg = mid + 1;
while (loBeg <= mid && hiBeg <= hi) {
if (array[loBeg] < array[hiBeg]) {
tArray[count] = array[loBeg];
loBeg++;
浏览 3提问于2015-10-28得票数 0
回答已采纳
1回答
将引用数组传递给模板指针数组
、、、、
我有一节课：
template<typename T>
class array_eraser
{
T* array;
int size_array;
public:
array_eraser(T &a[], int s)
{
size_array = s;
array = new T[s];
array = a;
}
}
我用这一行来调用这个类：
std::string langs[] = { "C++", "Haskell", "Ada"
浏览 10提问于2020-12-13得票数 0
回答已采纳
1回答
这段代码：
#include <array>
#include <iostream>
int function()
{
const int N=10000000;
std::array<double, N> array{0.0};
std::cout<<"N="<<N<<std::endl;
return 0;
}
int main(int, char **)
{
function();
exit(0);
}
当我启动这个计划时，我看到：
Segmentation fault (
浏览 1提问于2019-07-17得票数 2
回答已采纳
2回答
我有以下代码：
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
typedef uint64_t Huge_num; // 8 bytes
typedef Huge_num * Huge_Arr; // Array of 8 byte elements
using namespace std;
// Function: Return a huge array
static Huge_Arr* requestMem(in
浏览 6提问于2013-01-30得票数 2
回答已采纳
4回答
在c++中扩展数组
、、、
嗯，我在互联网上搜索了动态扩展数组，发现这在C++中是不可能的。我必须使用malloc、C版本的realloc或C++中的std::vector。但是下面的代码似乎工作得很好。
#include<iostream>
using namespace std;
int main() {
int len = 10;
int *p = new int[len];
for (int i = 0; i < len; i++){
p[i] = i + 1;
}
*(p + len) = 1000; // extend here.
浏览 0提问于2014-02-07得票数 1
当我声明std::vector<std::string> v时，我可以很容易地检查它是否包含给定的字符序列
if ( std::find( v.begin(), v.end(), "abc" ) != v.end() )
{
// some logic if contains
}
但是，如果我使用std::vector<const char*> v并尝试应用相同的逻辑来查找给定的字符序列，那么我的代码就不能正常工作。
是什么导致了这个问题？我怎样才能解决这个问题？
编辑
最快的解决方案(我关心性能，这就是为什么我拒绝std::string)
bo
浏览 0提问于2021-07-22得票数 0
回答已采纳
我试图将一个initializer_list分配给std：：initializer_list，如下所示：
std::array<int,2> arr = {0,1};
arr = {0,1,2};
我立刻收到一个错误，说operator=没有可行的重载
我知道我不能尝试分配一个大小大于数组大小的初始化程序列表，但我只是想了解std::array是如何做到这一点的。
我试着查看的代码，但没有看到重载的operator=。那么std：：数组是如何使用默认的operator=将这些尝试标记为编译器错误的。默认的operator=如何知道检查initializer_list的大小？请帮我理
浏览 2提问于2018-12-05得票数 1
回答已采纳
1回答
我对布局std140和std430之间的差异有困难。
这是我在.Cpp中的.Cpp代码
struct Particle {
glm::vec3 position = glm::vec3(0);
float density = 1;
};
for (int z = 0; z < d; ++z) {
for (int y = 0; y < d; ++y) {
for (int x = 0; x < d; ++x) {
int index = z * d * d + y * d + x;
i
浏览 18提问于2022-08-01得票数 0
我正在解决一个问题，这个问题需要5维数组(动态分配)，步骤数至少为1000。该代码适用于50个步骤。然而，当步骤数增加时，它会给出一个错误'terminate called what()：std::bad_alloc Aborted (core dumped)‘。有什么建议吗？
浏览 14提问于2019-05-24得票数 0
我正在从一个.txt文件中读取网络数据，以便使用Boost图形库创建一个图形。
数据的格式如下：
[num_nodes] [num_edges]
[source_node] [target_node]
[from_node] [to_node] [arc_weight_1] [arc_weight_2]
...
[from_node] [to_node] [arc_weight_1] [arc_weight_2]
例如,
264346 733846
229246 264275
1 2 803 2008
...
259707 261228 389 389
在下面的代码片段中，我将初始化一个成对数
浏览 0提问于2018-04-04得票数 2
回答已采纳
4回答
当声明像std::array<std::string, 5> myArray = ...这样的字符串数组时，它是如何存储在内存中的？
在数组中，元素应该顺序地存储在内存中，但是任何k元素都应该可以在恒定时间内通过索引访问，那么，它如何处理可变长度的字符串呢？
浏览 1提问于2014-12-07得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
