C++ 如何创建具有动态大小的数组？动态数组的一般用法（也可能是指针）？

我正在制作一个程序

接受用户输入（假设所有输入都是

int

）

将其存储在没有起始大小的数组中（即非->

数组[5]；

）；然后

将存储在数组中的信息用于任何险恶目的

我在寻求帮助，这样我就可以学会如何在需要的时候自己做这件事

• 如何在没有设置大小的情况下创建动态数组
• 如何使用/访问/访问上述数组中的元素

读书对我来说还不够

---

我知道这是一个非常不切实际的问题，是的，我是一个不切实际的人，但要改变这一点，我需要一些帮助。对于C++：

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

std:vector

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

GrowingArray

（类似于标准提供的

vector

类）

编辑

要详细说明我的回答（考虑到您将此用于学习目的）：

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

在这里，您需要使用如下内容：

int*myDynamicArray
当用户输入一些值时，您将内存块分配到存储这些值的位置：
myDynamicArray=newint[5]代码。我建议将数组的大小保存在某个变量中：
intarraysize=5
如果以后要将新值附加到
myDynamicArray
中，首先必须为已增长的数组分配新内存块（当前数组元素+新数组元素）。假设有10个新值即将出现。然后你会做：
int*grownArray=newint[arraySize+10]这为数组分配新的内存块。然后，您需要将项目从旧内存块复制到新内存块，并添加用户附加值（我认为您是出于学习目的而使用它，因此我为您提供了复制元素的简单周期。您也可以使用
std:copy
或类似于
memcopy
的c）：

inti=0；
对于（；i<代码> > p>这里我写了一些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;
}

#包括
int main（int argc，char*argv[]）
{
int*我的动态数组；
整数大小；
标准：cin>>尺寸；
my_dynamic_数组=新整数[大小]；
对于（intk=0；k来说，这可能是最聪明的（在某些情况下，隐晦地过度使用STL）方法

std:：向量向量向量机；
//从用户处一次读取整数1，
//输入非整数输入时将停止
std:：copy（std:：istream_迭代器（std:：cin），
std:：istream_迭代器（），
标准：背向插入器（vec）；
//打印出向量
std：：copy（vec.begin（）、vec.end（）、std：：ostream_迭代器（std：：cout，“”）；
在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));

inti=0；
int*p；
字符c；
整数大小；
printf（“输入大小：”）；
scanf（“%d”，大小（&S）；
int*p=malloc（sizeof（int）*size）；
做
{
printf（“输入编号：”）；
scanf（“%d”和&p[i]）；
i++；
printf（“按'q'或'q'退出，或按任何其他键继续：”）；
scanf（“%c”、&c）；
}
（c！='q'&&c！='q'&&i我给你一个建议。如果你打算用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);
   }

}

C或C++？每个查询都有不同的建议。查找：如果使用C++，C，你应该学会使用<代码> MalOC ……你可以使用ARCC获得参数的大小，并基于你可以做int数据[ARCC - 1 ]。C和C++是非常不同的语言。这是一个很可怕的问题。谢谢你的并排代码/解释！如果你帮助了你，请把答案标记为“接受”。你也可以从上面的代码中填补一些空白：谢谢！编译器是如何知道有多少元素可以被<代码>删除[]？
如果数组是动态的？它是否以某种方式保留了对
大小的引用？这里唯一值得一提的答案。
copy（std:：istream_iterator（std:：cin），{}，std:：ostream_iterator（std:：cout，”）；
对于lot:）不幸的是，访问时间是O（n）
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));

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);
   }

}