是否可以动态分配向量?

Is it possible to dynamically allocate a vector?

本文关键字：向量 动态分配 是否      更新时间：2023-10-16

我被告知在这个特定的解决方案中使用向量而不是数组(我的原始解决方案用于动态分配数组)我的问题是我并不真正理解向量，我的书只涵盖了一小部分。所以，也许我做错了什么？我只是想学习一种用向量解决它的不同方法。所以，当我问是否可以动态分配一个向量时。我的意思是，如果不是为什么，那么std::vector<int*> vect= nullptr;这样做是合法的吗？此外，查看如何使用向量修改我的原始解决方案的示例将非常有帮助。 我是一个初学者，只是想从错误中吸取教训。

#include <iostream>
#include <vector>
void sortAscendingOrder(int*, int );
void LowestTestScore(int*, int);
void calculatesAverage(int*,int);
int main()
{
std::vector<int*> vect= nullptr;
int input;
std::cout << "Enter the number of testscores you want to enter." <<std::endl;
std::cin >> input;
vect = new int[input];
for(int count =0; count < input; count++)
{
std::cout << "Enter the test score" << (count +1) <<":" <<std::endl;
std::cin >> vect[count] ;
while( vect[count] < 0)
{
std::cout <<"You enter a negative number. Please enter a postive number." <<std::endl;
std::cin >> vect[count];
}
}
sortAscendingOrder(vect,input);
for(int count =0; count < input;count++)
{
std::cout << "n" <<vect[count];
std::cout << std::endl;
}
LowestTestScore(vect,input);
calculatesAverage(vect,input);

return 0;
}
void sortAscendingOrder(int* input,int size)
{
int startScan,minIndex,minValue;
for(startScan =0; startScan < (size-1);startScan++)
{
minIndex = startScan;
minValue = input[startScan];
for(int index = startScan+1;index<size;index++)
{
if(input[index] < minValue)
{
minValue = input[index];
minIndex = index;
}
}
input[minIndex]=input[startScan];
input[startScan]=minValue;
}
}
void LowestTestScore(int* input, int size)
{
int count =0;
int* lowest = nullptr;
lowest = input;
for(count =1; count <size;count++)
{
if(input[count] < lowest[0])
{
lowest[0] = input[count];
}
}
std::cout << "Lowest score" << *lowest;
}
void calculatesAverage(int* input, int size)
{
int total = 0;
int average =0;
for(int count = 0; count < size; count++)
{
total += input[count];
}
average =(total/size-1);
std::cout << "Your average is" << average;
}

如果要在运行时增加数组的大小，则需要动态分配数组。就像数组一样，向量为其元素使用连续的存储位置。但是，与阵列不同，它们的大小可以动态变化，它们的存储由容器自动处理。

每次将元素添加到容器时，向量都不会重新分配。它预先分配了一些额外的存储空间以适应未来的增长。库可以实现不同的增长策略，以平衡内存使用和重新分配，但无论如何，重新分配应该只以大小的对数增长间隔进行，以便向量末尾插入单个元素可以提供摊销的常量时间复杂度(参见push_back)

要回答您的问题： 是的，可以动态分配向量，不，它不需要额外的努力，因为std:vector已经这样做了。因此，动态分配向量是一项多余的工作。

你可以写：

#include<vector>
typedef std::vector< std::vector<double> >vec_array;
vec_array name(size_x, std::vector<double>(size_y));

这意味着：size个std::vector<double>实例，每个实例包含size_y双精度(初始化为0.0)。

或者，您可以简单地使用 vector 来增加容器大小(知道它自己处理存储需求)，例如：

#include <vector>
vector<int> vec_array;
int i;
for(i=0;i<10;i++)
vec_array.push_back(i);
相关文章：