Question

我被告知在这里使用向量而不是数组来解决这个特殊的解决方案（My original solution using to dynamically allocate arrays）我的问题是我真的不理解向量，我的书只涵盖了一小部分。那么，也许我做错了什么？我只是想通过向量来学习一种不同的解决方法。所以，当我问到是否有可能动态分配一个向量。我的意思是这样做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;
}

Answer 1

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

每次将元素添加到容器时，矢量都不会重新分配。它预先分配了一些额外的存储空间以适应未来的增长。库可以实现不同的增长策略以在内存使用和重新分配之间取得平衡，但无论如何，重新分配应该仅以对数增长的大小间隔发生，以便在向量的末尾插入单个元素可以提供摊销的常量时间复杂性（见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);

是否可以动态分配向量？

1 个答案: