如何制作动态大小的数组？动态数组的一般用法（也许还有指针）？ [已关闭]

问题描述 投票：0回答：5

我正在尝试制作一个程序，

  1. 接受用户输入（假设所有内容都是
    int
    ）
  2. 将其存储在没有起始大小的数组中（即不是 -> 
    array[5];
    ）；然后
  3. 将数组中存储的信息用于任何邪恶目的。

我寻求帮助，以便我可以在需要时学习如何自己执行此操作。

  • 如何制作没有设定大小的动态数组？
  • 如何使用/访问/到达上面数组中的元素？

阅读对我来说还不足以解释。

我知道这是一个非常菜鸟的问题，是的，我是菜鸟，但要改变这一点我需要一些帮助。

c++ c arrays pointers dynamic
5个回答
18
投票

对于 C++：

如果您只需要一个容器，只需使用

std:vector
。它将照顾您所需的所有内存分配。但是，如果您想开发自己的动态容器（无论您有什么原因），您必须自己处理内存分配。也就是说，当数组增长时，您必须分配新的内存块，将当前数组值复制到新的内存位置，并将新值添加到新分配的内存中。通常，人们将这种逻辑包装在一个单独的类中，例如
GrowingArray
（如标准提供的
vector
类）

编辑

详细说明我的答案（假设您将此用于学习目的）：

将其存储在没有起始大小的数组中（即不是 -> array[5];）

这里你想使用这样的东西：

int * myDynamicArray;
当用户输入一些值时，您会分配将存储这些值的内存块：
myDynamicArray = new int[5];
，其中包含初始输入的大小。我还建议将数组的大小保存在某个变量中：
int arraySize = 5;
如果稍后您想将新值附加到 
myDynamicArray
，首先您必须为增长的数组分配新的内存块（当前数组元素+新数组元素）。假设您有 10 个新值即将到来。然后你会这样做： 
int* grownArray = new int[arraySize+10];
这为增长的数组分配新的内存块。然后，您想要将旧内存块中的项目复制到新内存块并添加用户附加值（我认为您将其用于学习目的，因此我为您提供了复制元素的简单循环。您可以使用 
std:copy
或 c也喜欢
memcopy
）：

int i = 0;
for (; i < arraySize; ++i)
   {
   grownArray[i] = myDynamicArray [i];
   }
// enlarge newly allocated array:
arraySize+= 10;
for (; i < arraySize; ++i)
   {
   grownArray[i] = newValues from somewhere
   }
// release old memory
delete[] myDynamicArray;
// reassign myDynamicArray pointer to point to expanded array
myDynamicArray = grownArray;
15
投票

这可能是最聪明的（对某些人来说神秘的过度使用 STL）方法......

std::vector<int> vec;

// read integers 1 at a time from the user,
// will stop when non-integer input is entered
std::copy(std::istream_iterator<int>(std::cin),
          std::istream_iterator<int>(), 
          std::back_inserter(vec));

// print out the vector
std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
10
投票

这是我用 C++ 编写的一些执行基础操作的代码。

#include <iostream>

int main(int argc, char *argv[])
{
    int* my_dynamic_array;

    int size;
    std::cin >> size;

    my_dynamic_array = new int[size];

    for (int k=0; k<size; k++)
        my_dynamic_array[k] = k;

    for (int k=0; k<size; k++)
        std::cout << my_dynamic_array[k] << std::endl;

    delete[] my_dynamic_array;

    return 0;
}

好的，这就是这段代码中发生的事情。我们使用 std::cin 提示输入数组的大小，然后使用 new 关键字为数组动态分配一些内存。这里有一些细节让人一开始看起来有点奇怪；这似乎让许多新 C++ 开发人员感到困惑。

首先我们用指针而不是数组声明来声明动态数组，例如我们使用 

int *my_dynamic_array
而不是 
int my_dynamic_array[]
。乍一看，这似乎有点微不足道，但您需要了解 C 和 C++ 中发生的事情。

当您静态声明一个数组时，您是在告诉程序您想要留出该内存供您使用。它实际上就在那里；它是您的，您可以开始使用。当您动态创建数组时，您从指针开始。指针只是对某些内存的引用。该内存尚未分配。如果您尝试使用 

my_dynamic_array[3]
等方式访问其中的某些内容，您将收到一个严重的错误。这是因为该位置的内存中实际上没有任何内容（至少没有任何内容可供程序使用）。

另请注意使用 

delete[]
而不是 
delete
。这就是使用完数组后释放内存的方式。

如果您在 C 中执行此操作，您几乎可以以相同的方式思考这一点，但您没有 

new
和 
delete[]
，而是使用 
malloc
和 
free
。

了解动态数组和指针之间的细微差别是很棘手的。我花了一段时间才完全明白发生了什么事。祝你好运并坚持下去。

0
投票

在C中你可以使用这个方法。

int i=0;
int *p;
char c;
int size; 
printf("Enter size :");
scanf("%d",&size); 
int *p=malloc(sizeof(int)*size);
do
{
 printf("Enter Number : ");
 scanf("%d",&p[i]);
 i++;
 printf("Press 'q' or 'Q' to quit or any other key to continue : ");
 scanf("%c",&c);
}
while(c!='q' && c!='Q' && i<=size);
p=realloc(p,i*sizeof(int));

通过这种方式，如果您想要的整数数量小于分配的内存，您可以释放剩余的分配的内存。

0
投票

我给你一个建议。如果你打算使用 C

进行开发，你可以使用链表代替数组

下面是一个例子：

typedef struct linked_list {
    int x,
    struct linked_list *next
} linked_list;

struct linked_list *head = NULL;

void add_element(int x)
{
    struct linked_list *elem;
    elem = malloc(sizeof(struct linked_list));
    elem->x =x;
    elem->next = head;
    head = elem;
}

int main()
{
   int x;
   struct linked_list *p;
   do
   {
       printf("Enter Number : ");
       scanf("%d",&x);
       add_element(x)
       printf("Press 'q' or 'Q' to quit or any other key to continue : ");
       scanf("%c",&c);
   }while(c!='q' && c!='Q');

   for (p=head;p!=NULL;p=p->next)
   {
        printf(%d\r\n",p->x);
   }

}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.