精华内容
下载资源
问答
  • 如何动态分配数组

    千次阅读 2013-09-26 13:03:57
    这里说的变长数组是指在编译时不能确定数组长度,程序在运行时需要动态分配内存空间的数组。实现变长数组最简单的是变长一维数组,你可以这样做: #include using namespace std; int main() { int len; cin>>...

    变长一维数组

    这里说的变长数组是指在编译时不能确定数组长度,程序在运行时需要动态分配内存空间的数组。实现变长数组最简单的是变长一维数组,你可以这样做:

    #include<iostream>

    using namespace std;

    int main()

    {

    int len;

    cin>>len;

    //用指针p指向new动态分配的长度为len*sizeof(int)的内存空间

    int *p=new int[len];

    ...........

    delete[] p;

    return 0;

    }

    注意int *p=new int[len];这一句,你不能这样做: int p[len]; C++编译器会报错说len的大小不能确定,因为用这种形式声明数组,数组的大小需要在编译时确定。而且这样也不行: int p[]=new int[len];编译器会说不能把int*型转化为int[]型,因为用new开辟了一段内存空间后会返回这段内存的首地址,所以要把这个地址赋给一个指针,所以要用int *p=new int[len];

    以上程序实现了一个变长的一维数组,但是要养成一个好习惯,就是注意要注销指针p,使程序释放用new开辟的内存空间。
     当然使用C++标准模版库(STL)中的vector(向量)也可以实现变长数组:

    #include<iostream>

    #include<vector>

    using namespace std;

    int main()

    {

    int len;

    cin>>len;

    vector<int> array(len);//声明变长数组

    for(int i=0;i<len;i++)

    {

    array[i]=i;

    cout<<array[i]<<"\t";

    }

    return 0;

    }

    2.变长二维数组

    用C++实现变长二维数组时可以采用两种方法:双指针方法和使用STL中vector(向量)的方法。

    首先介绍一下双指针方法,在这里双指针就是指像指针的指针,比如你可以这样声明一个数组:

    int **p = new int*[num1];

    而对每一个*p(一共num1个*p)申请一组内存空间:

    for(int i=0; i<num1; ++i)

     p[i] = new int[num2];

    其中,num1是行数,num2是数组的列数。测试的源程序如下:

    #include <iostream>

    #include <iomanip>

    using namespace std;

    int main()

    {

    int num1;//行数

    int num2;//列数

    cout<<"Please enter the number for row and column: "<<endl;

    cin >> num1 >> num2;

    //为二维数组开辟空间

    int **p;

    p= new int*[num1];

    for(int i=0; i<num1; ++i)

    p[i] = new int[num2];

    for(int j=0;j<num1;j++)

    {

    for(int k=0;k<num2;k++)

    {

     p[j][k]=(j+1)*(k+1);

     cout<<setw(6)<<p[j][k]<<':'<<setw(8)<<&p[j][k];

    }

    cout<<endl;

    }

    //释放二维数组占用的空间

    for(int m=0;m<num1;m++)

    delete[] p[m];

    delete[] p;

    return 0;

    }

    用vector(向量)实现二维数组,以下给出源程序:

    #include <iostream>

    #include <vector>

    #include <iomanip>

    using namespace std;

    int main()

    {

    int i,

     j,

     m, //行数

     n; //列数

    cout << "input value for m,n:";

    cin>>m>>n;

    //注意下面这一行:vector<int后两个">"之间要有空格!否则会被认为是重载">>"。

    vector<vector<int> > vecInt(m, vector<int>(n));

    for (i = 0; i < m; i++)

    for (j = 0; j < n; j++)

     vecInt[i][j] = i*j;

     

    for (i = 0; i < m; i++)

    {

    for (j = 0; j < n; j++)

     cout<<setw(5)<<vecInt[i][j]<<":"<<setw(9)<<&vecInt[i][j];

    cout<<endl;

    }

    return 0;

    }

    3.变长三维数组

    根据以上一、二维数组,可以推出三维数组的实现。以下是指针实现代码:

    #include <iostream>

    using namespace std;

    void main()

    {

     int ***p3;

     intx=3,y=2,z=2;

     p3=new int **[x];

     for (i=0;i<x;i++)

     {

     p3[i]=new int* [y];

     for (int j=0;j<y;j++)

     {

     p3[i][j]=new int[z];

     for (int k=0;k<z;k++)

     {

     p3[i][j][k]=i*j*k;

     }

     }

     }

     for (int k=0;k<z;k++)

     {

     for (int i=0;i<x;i++)

     {

     for (int j=0;j<y;j++)

     cout<<p3[i][j][k]<<" " ;

     cout<<endl;

     }

     cout<<endl;

     }


     for (int i=0;i<x;i++)

     {

     for (int j=0;j<y;j++)

     {

     delete [] p3[i][j];

     }

     delete [] p3[i];

     }

     delete [] p3;

    }

    以下是vector实现代码:

    #include <iostream>

    #include <vector>

    using namespace std;

    void main()

    {

     int m=2;

     int n=3;

     int l=4;

     vector<vector<vector<int> > > v(m,vector<vector<int> >(n,vector<int>(l)));

     v[1][2][3]=4;

     cout<<v[1][2][3]<<endl;

    }

    4.用一维动态数组表示二维、三维动态数组

    以下是程序代码:

    #include <iostream>

    using namespace std;

    void main()

    {

     int m=3,n=4,l=2;

     int *p2; //将表示二维数组

     p2=new int[m*n];

     int i,j,k;

     for (i=0;i<m;i++)

     for(j=0;j<n;j++)

     {

     p2[i*n+j]=i+j;

     }

     cout<<"二维数组"<<endl;

     for (i=0;i<m;i++)

     {

     for(j=0;j<n;j++)

     {

     cout<<p2[i*n + j]<<" ";

     }

     cout<<endl;

     }

     delete []p2;

     int *p3; //将表示三维数组

     p3=new int[m*n*l];

     for (k=0;k<l;k++)

     for (i=0;i<m;i++)

     for (j=0;j<n;j++)

     {

     p3[k*n*m + i*n + j]=i+j+k;

     }

     cout<<"三维数组"<<endl;

     for (int k=0;k<l;k++)

     {

     for (int i=0;i<m;i++)

     {

     for (int j=0;j<n;j++)

     cout<<p3[k*n*m + i*n + j]<<" " ;

     cout<<endl;

     }

     cout<<endl;

     }

     delete []p3;

    }

    转自:http://www.cnblogs.com/rollenholt/articles/1907415.html
    展开全文
  • 比如我要产生一个二维的数组,但是数组的行数和列数都不确定,而且每一行的数组元素 也不相同。如果用泛型list的话,是不是可以实现这种过程?应该怎么声明list呢
  • 如果我知道我有多少个元素,我已经知道如何创建一个固定数组。例如,对于7个元素,我做了一些类似于int数组[2][4]的事情。但是,如果我在开始时有0个元素(这意味着数组在开始时是空的),并且希望随着程序的运行增加...

    如果我知道我有多少个元素,我已经知道如何创建一个固定数组。例如,对于7个元素,我做了一些类似于int数组[2][4]的事情。

    但是,如果我在开始时有0个元素(这意味着数组在开始时是空的),并且希望随着程序的运行增加数组的大小呢?

    基本上,如何添加新行或新列?

    你考虑过使用列表吗?

    使用ArrayList?

    数组根据定义是固定长度的。如果需要动态长度,请使用列表。

    这就是不可能调整大小的原因。无论您有1或20个维度,数组的每个维度都被分配为某个位置的连续数据行,并且任何此类序列之后的存储空间对于其他变量和要使用的数据都是公平的。例如,ary=new int[4]可以在内存中表示,如下所示:2

    由于数组数据之后可能会有其他变量,因此必须分配一个具有所需大小的新数组,并将所有元素从旧数组复制到新数组。一种策略是,每次达到100%的容量时,将分配大小加倍,以获得恒定的摊余时间复杂性。这或多或少是阿拉里斯特所做的,但正如彼得·劳里所指出的,这浪费了大量的空间。

    根据需要,另一种选择可能是LinkedList,其中每个数据元素都是单独分配的,并且包含指向下一个/上一个元素的指针。尽管链接列表非常紧凑(没有浪费的空间),并且能够增长到任何大小,但它有两个主要缺点:

    无随机访问(只能从一个元素遍历到下一个/上一个元素)。

    非常低效的时间——跨越地址空间到达每个下一个元素完全击退了CPU缓存的风。

    编辑:再想一想……即使二维链表是可能的,但你需要多个维度的事实可能意味着顺序遍历对你来说还不够。我的错。

    虽然Java中的数组存储在连续的内存块中,但对于二维数组来说,这一点是不成立的。二维数组的每个元素都是对一维数组的引用,但每个引用的元素都可以存储在内存的任何位置。例如,请参阅另一个线程中的这个日志。

    谢谢你,先生-我向读者们道歉。应该比从C语言中进行假设更清楚。在上面编辑过。

    注意,new int[2][4]是int[]的数组;int[][]数组中的int[]数组最初都是相同的长度,但不要求它们保持相同的长度。int[][]数组的任何元素都可以重新分配长度不同的int[],而不会影响其他元素。"行"和"列"的概念是Java阵列不支持的更高级的概念。

    如其他答案所示,使用ArrayList不会改变这一点。此外,根据使用ArrayList的方式,由于int值作为Integer对象自动氧化,可能会导致相当大的开销。

    如果要保留数据的矩形形状,我建议您定义一个Matrix类,它保持所有维度的一致性。(或者,也许更好,将二维数组线性化为一维数组,并使用内部存储的行和列大小进行适当的订阅计算。或者,最好是使用一个写得很好的矩阵库,比如jama或者像trove这样的原始集合库。)

    这里是一个简单的矩阵类的开始,它在内部使用线性存储方案并允许矩阵大小调整。数据以行主顺序存储,索引基于0。

    public class IntMatrix {

    private int rows;

    private int cols;

    private int[] data;

    /**

    * Allocate a matrix with the indicated initial dimensions.

    * @param cols The column (horizontal or x) dimension for the matrix

    * @param rows The row (vertical or y) dimension for the matrix

    */

    public IntMatrix(int cols, int rows) {

    this.rows = rows;

    this.cols = cols;

    data = new int[cols * rows];

    }

    /**

    * Calculates the index of the indicated row and column for

    * a matrix with the indicated width. This uses row-major ordering

    * of the matrix elements.

    *

    * Note that this is a static method so that it can be used independent

    * of any particular data instance.

    * @param col The column index of the desired element

    * @param row The row index of the desired element

    * @param width The width of the matrix

    */

    private static int getIndex(int col, int row, int width) {

    return row * width + col;

    }

    public int get(int col, int row) {

    return data[getIndex(col, row, cols)];

    }

    public void set(int col, int row, int value) {

    data[getIndex(col, row, cols)] = value;

    }

    /**

    * Resizes the matrix. The values in the current matrix are placed

    * at the top-left corner of the new matrix. In each dimension, if

    * the new size is smaller than the current size, the data are

    * truncated; if the new size is larger, the remainder of the values

    * are set to 0.

    * @param cols The new column (horizontal) dimension for the matrix

    * @param rows The new row (vertical) dimension for the matrix

    */

    public void resize(int cols, int rows) {

    int [] newData = new int[cols * rows];

    int colsToCopy = Math.min(cols, this.cols);

    int rowsToCopy = Math.min(rows, this.rows);

    for (int i = 0; i < rowsToCopy; ++i) {

    int oldRowStart = getIndex(0, i, this.cols);

    int newRowStart = getIndex(0, i, cols);

    System.arraycopy(data, oldRowStart, newData, newRowStart,

    colsToCopy

    );

    }

    data = newData;

    }

    . . .

    }

    如果我想在数组中,行代表x,列代表y,点A的坐标(x,y)。我正在努力做这样的事情并扩展它(我的英语不好)。我不能使用列表,因为列表是线性的,我需要它看起来像一个表(双数组)。

    @我添加了一些示例代码来演示如何在内部使用一维数组。还可以看看另一个问题的答案。

    @用户2995645阵列列表是O(1)随机访问。

    ArrayList文档和示例。享受!

    明确地:

    ArrayList list = new ArrayList();

    list.add(1); // Add 1 to the list.

    如果我想在数组中,行代表x,列代表y,点A的坐标(x,y)。我正在努力做这样的事情并扩展它(我的英语不好)。我不能使用列表,因为列表是线性的,我需要它看起来像一个表(双数组)。

    当然,您可以使用集合(例如arraylist),但是如果您想使用二维矩阵,您可以"即时"创建不同大小的行。例如,下面的示例创建"三角形"矩阵:

    int[][] matrix = new int[3][];

    int count = 0;

    for (int i = 0; i < 3; i++) {

    matrix[i] = new int[i];

    for (int j = 0; j < i; j++) {

    matrix[i][j] = ++count;

    }

    }

    可以动态创建Java数组,但不能动态扩展。您可能希望按照其他建议查看向量或数组列表。

    然而,请记住,在您的示例中,您已经创建了一个矩阵,这是一个稍微不同的东西。

    创建一个更大的新数组,复制现有元素并添加要添加的元素。您可以使用类似arraylist的东西,但这是昂贵的,将使用大约4倍的内存。如果不想自己调整数组的大小,我会考虑使用TDoubleArrayList。

    如果Op的问题是在保持矩形结构的同时调整矩阵的大小,那么Trove的原始数组列表并不是一个完整的解决方案。

    @泰德霍普是的,你需要一份这些的清单,即Listmatrix

    展开全文
  • C语言中动态分配数组(一维)当初学Pascal的时候就想过这个问题:如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用...

    C语言中动态分配数组(一维)

    当初学Pascal的时候就想过这个问题:如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于找到了C语言中的用法(看原贴):

    int *a;

    int N;

    scanf("%d", &N);

    a = (int *) malloc(N * sizeof(int));

    ....

    free(a);

    这样就动态分配了数组a[N]。数组的长度N可输入确定,也可用程序中的变量确定。但要注意程序结束后要用free()将其释放,否则内存会泄漏。

    --------------------------------------------------------------------------------

    验证一下:

    #include

    #include

    int main()

    {

    int i = 0;

    int *a;

    int N;

    printf("Input array length: ");

    scanf("%d", &N);

    printf("\n");

    a = (int *) malloc(N * sizeof(int));

    for(i = 0; i < N; i++)

    {

    a[i] = i + 1;

    printf("%-5d", a[i]);

    if ((i + 1) % 10 == 0)

    printf("\n");

    }

    free(a);

    printf("\n");

    return 0;

    }

    运行结果(VC):

    =========================================================

    Input array length: 100↙

    1    2    3    4    5    6    7    8    9    10

    11   12   13   14   15   16   17   18   19   20

    21   22   23   24   25   26   27   28   29   30

    31   32   33   34   35   36   37   38   39   40

    41   42   43   44   45   46   47   48   49   50

    51   52   53   54   55   56   57   58   59   60

    61   62   63   64   65   66   67   68   69   70

    71   72   73   74   75   76   77   78   79   80

    81   82   83   84   85   86   87   88   89   90

    91   92   93   94   95   96   97   98   99   100

    =========================================================

    展开全文
  • 以下是在堆上创建2D数组(或动态分配2D数组)的不同方法。在以下示例中,我们将“r”视为行数,将“c”视为列数,并创建了一个二维数组,其中r = 3,c = 4,并遵循以下值 1 2 3 4 5 6 7 8 9 10 11 121.使用单个指针:...

    以下是在堆上创建2D数组(或动态分配2D数组)的不同方法。

    5b3de1c233dfc3dbfaaba5dc7e3c486e.png

    在以下示例中,我们将“ r ”视为行数,将“ c ”视为列数,并创建了一个二维数组,其中r = 3,c = 4,并遵循以下值

      1 2 3 4
    5 6 7 8
    9 10 11 12

    1.使用单个指针:
    一种简单的方法是使用简单的指针算法分配大小为r * c的存储块和访问元素。

    #include 
    #include
    int main()
    {
    int r = 3, c = 4;
    int *arr = (int *)malloc(r * c * sizeof(int));
    int i, j, count = 0;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    *(arr + i*c + j) = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", *(arr + i*c + j));
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12

    2.使用指针数组
    我们可以创建大小为r的指针数组。请注意,从C99开始,C语言允许使用可变大小的数组。创建指针数组后,我们可以为每行动态分配内存。

    #include 
    #include
    int main()
    {
    int r = 3, c = 4, i, j, count;
    int *arr[r];
    for (i=0; i arr[i] = (int *)malloc(c * sizeof(int));
    count = 0;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    arr[i][j] = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", arr[i][j]);
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12

    3.使用指向指针的指针
    我们还可以使用双指针动态创建指针数组。一旦我们动态分配了数组指针,就可以像方法2一样为每行动态分配内存。

    include 
    #include
    int main()
    {
    int r = 3, c = 4, i, j, count;
    int **arr = (int **)malloc(r * sizeof(int *));
    for (i=0; i arr[i] = (int *)malloc(c * sizeof(int));
    count = 0;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    arr[i][j] = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", arr[i][j]);
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12

    4.使用双指针和一个malloc调用

    #include
    #include
    int main()
    {
    int r=3, c=4, len=0;
    int *ptr, **arr;
    int count = 0,i,j;
    len = sizeof(int *) * r + sizeof(int) * c * r;
    arr = (int **)malloc(len);
    ptr = (int *)(arr + r);
    for(i = 0; i < r; i++)
    arr[i] = (ptr + c * i);
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    arr[i][j] = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", arr[i][j]);
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12
    展开全文
  • 多维数组,每个元素由值及多个能确定元素位置的下标组成,按数组的多个下标变化次序关系的描述,可以确定数组元素的前驱和后继关系并写出对应的线性表。
  • C语言动态分配数组

    千次阅读 2016-06-22 13:45:46
    如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的,后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于找到了C语言中的用法(看原贴): ...
  • 第一个参数是内存块中的元素数量(即大小为30 000的数组) . 第二个参数是一个块的大小(即数组中的一个元素) .所以你会这样称呼它:ptr = calloc(30000, sizeof(float));在您的情况下使用 calloc 存在一个瓶颈,因为...
  • C++ Primer Plus 第四章操作题 6.结构CandyBar包含3个成员,如...方法:使用new创建动态数组如何访问其中的元素?只要把指针当作数组名使用即可。声明一个包含3个元素的数组 #include<iostream> #include<...
  • 如何分配动态数组

    2013-11-11 19:53:55
    如何分配动态数组,以及内存的回收,还有与其他情况的对比。 #include using namespace std; void main(void) { cout; cout静态对象"; //静态对象 int a; a=1; cout; cout<<"------
  • C语言中动态分配数组

    2016-05-31 16:04:00
    如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于...
  • C++ Code:动态分配数组内存的六种方法

    万次阅读 多人点赞 2017-12-25 10:30:36
    问题:  如何快速给数组分配自定义长度的... 提到动态分配C++的数组,我们想到的标签会有:malloc-free、new-delete、一维、二维...等等,本博客初创初心是各大公司企业都会青睐于在笔试或者面试中,要求应届生具备
  • C 语言动态分配数组

    2013-10-04 10:34:00
    如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于...
  • 就属于静态分配,而如何根据需要动态分配数组大小就显得尤为重要。 2. 实现: 2.1 平台: WinCE6.0 + VS2005 2.2 实现方法:使用new运算符动态分配一个变量指定的数组,使用完该数组后,再用delete运算符将其从...
  • 我们都知道要实现根据程序的需要动态分配存储空间,在C中需要使用到stdlib.h中的两个函数,malloc,free,两个函数的介绍如下: malloc函数的原型为: void *malloc (u igned int size) 其作用是在内存的动态存储区...
  • 如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于...
  • 问题:  如何快速给数组分配自定义长度... 提到动态分配C++的数组,我们想到的标签会有:malloc-free、new-delete、一维、二维...等等,本博客初创初心是各大公司企业都 会青睐于在笔试或者面试中,要求应届生具...
  • 我该如何动态分配多维数组

    千次阅读 2014-06-06 10:42:31
    我该如何动态分配多维数组? 传统的解决方案是分配一个指针数组, 然后把每个指针初始化为动态分配的“列”。以下为一个二维的例子:#include int **array1 = malloc(nrows * sizeof(int *));for(i = 0; i array1[i] =...
  • 如何动态创建数组

    2015-07-08 15:41:58
       ...我们知道在C或C++里,有时候我们要定义的数组的长度是不定的,所以要动态地创建数组,也就是在运行的时候动态分配内存。 我们常用的是对一维或二维数组动态的创建,但毕竟有时候我们要
  • 问题:如何动态的定义及使用数组呢? 记得一般用数组的时候都是先指定大小的。在C++里用new可以做到,纯C语言好像没法做到,今天在逛的时候终于找到了C语言中的用法(看原贴): int *a; int N; scanf("%d", &N);...
  • C语言如何动态分配二维数组 使用malloc()、free()函数进行动态分配,这两个函数包含于stdlib.h或malloc.h中 假如要申请一个3行5列的二维数组内存 1 #include <stdlib.h> 2 int main() 3 { ...
  • SystemVerilog中是否有一种方法可以创建一个连续分配其内存的动态数组?我正在尝试将数据从文件读入动态数组 . 问题似乎是动态数组不在连续的内存位置,因此文件无法正确读入数组 .当我声明变量读取文件为非动态数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 854
精华内容 341
关键字:

如何动态分配数组