精华内容
下载资源
问答
  • 创建动态数组

    2019-09-25 08:44:29
    1、初始化动态分配的数组 如果数组元素具有类型,将使用该类的默认构造函数初始化,如果是内置类型,则无初始化: string *psa = new string[10]; //array of 10 empty strings int *pia = new int[10]; //...

    1、初始化动态分配的数组

    如果数组元素具有类型,将使用该类的默认构造函数初始化,如果是内置类型,则无初始化:

    string *psa = new string[10];    //array of 10 empty strings

    int *pia = new int[10];        //array of 10 uninitialized ints

    也可以使用跟在数组长度后面的一对空圆括号,对数组元素作值初始化

    int *pia2 = new int[10]();      //array of 10 uninitialized ints

    圆括号要求编译器对数组做值初始化,此处把数组元素都设置为0

    2、const对象的动态数组

    在堆中创建的数组存储内置类型的const对象,必须为这个数组提供初始化:因为数组元素都是const对象,无法赋值,唯一方法就是对数组做值初始化:

    //error:uninitialized const array

    const int *pci_bad = new const int[100];

    //ok:value-pci_ok = new const int[100]();

    C++允许定义类类型的const数组,但该类类型必须提供默认构造函数。

    以创建的常量元素不允许修改——因此这样的数组实际上用处不大。

    3、允许动态分配空数组

    C++虽然不允许定义长度为0的数组变量,但是明确指出,调用new动态创建长度为0的数组时合法的

    char arr[0];      //error:cannot define zero-length array

    char *cp = new char[0];      //ok:but cp can't be dereferenced

    用new动态创建长度为0的数组时,new返回有效地非零指针。该指针与new返回的其他指针不同,不能进行解引用操作,因为它毕竟没有指向任何元素。允许的操作:比较运算;在该指针上加(减)0;或者减去本身,得0;

    转载于:https://www.cnblogs.com/BeyondTechnology/archive/2010/09/29/1838061.html

    展开全文
  • C++创建动态数组

    2014-06-01 12:58:41
    C++创建动态数组,注意有的编程软件会自动释放动态分配的内存
  • 使用new创建动态数组 创建动态数组: int *psome = new int [10]; 释放动态数组: delete [] psome; 使用动态数组 “C和C++内部都使用指针来处理数组。” “下面的程序演示了如何使用new来创建动态数组以及使用...
    1. 使用new创建动态数组
      创建动态数组:
      int *psome = new int [10];
      释放动态数组:
      delete [] psome;

    2. 使用动态数组
      “C和C++内部都使用指针来处理数组。”

    “下面的程序演示了如何使用new来创建动态数组以及使用数组表示法来访问元素;它还指出了指针和真正的数组名之间的根本差别:”

    #include <iostream>
    
    int main()
    {
        using namespace std;
    
        double *p3 = new double [3];
        p3[0] = 0.2;
        p3[1] = 0.5;
        p3[2] = 0.8;
    
        cout << "p3[1] is " << p3[1] << ".\n";
        p3 = p3 + 1;
        cout << "Now p3[0] is " << p3[0] << " and "
            << "p3[1] is " << p3[1] << ".\n";
        p3 = p3 - 1;            //point back to beginning.
        delete [] p3;           //free the memory.
    
        return 0;
    
    }
    

    在这里插入图片描述

    展开全文
  • 动态数组相对于一般数组的优势是可以灵活地添加或删除元素。而一般数组则受限于固定的内存空间。只能有限的添加元素动态数组(Dynamic Array)接口设计◼ int size(); // 元素的数量◼ boolean isEmpty(); // 是否为空...

    数组是一种顺序存储的线性表,所有元素的内存地址是连续的。

    动态数组相对于一般数组的优势是可以灵活地添加或删除元素。而一般数组则受限于固定的内存空间。只能有限的添加元素

    动态数组(Dynamic Array)接口设计

    ◼ int size(); // 元素的数量

    ◼ boolean isEmpty(); // 是否为空

    ◼ boolean contains(E element); // 是否包含某个元素

    ◼ void add(E element); // 添加元素到最后面

    ◼ E get(int index); // 返回index位置对应的元素

    ◼ E set(int index, E element); // 设置index位置的元素

    ◼ void add(int index, E element); // 往index位置添加元素

    ◼ E remove(int index); // 删除index位置对应的元素

    ◼ int indexOf(E element); // 查看元素的位置

    ◼ void clear(); // 清除所有元素

    上代码:

    动态数组类的实现:

    public class ArrayList {

    //动态数组至少应该有数组的长度和元素的索引两个成员变量。

    /**

    * 元素的数量

    */

    private int size;

    /**

    * 所有的元素

    */

    private E[] elements;

    //在创建数组时要有一个初始的容量,容量的大小根据实际情况确定,避免重复申请或销毁内存。

    private static final int DEFAULT_CAPACITY = 10;

    //这里用来进行判定

    private static final int ELEMENT_NOT_FOUND = -1;

    public ArrayList(int capaticy) {

    //如果实际需要的容量比默认容量小,就使用默认容量

    capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;

    elements = (E[]) new Object[capaticy];

    }

    public ArrayList() {

    this(DEFAULT_CAPACITY);

    }

    /**

    * 清除所有元素

    */

    public void clear() {

    //为了使动态数组可以存储多种类型的元素使用了泛型

    //这样的话new的数组里每个位置存储的是元素内存的索引

    //这样清空的时候需要将每个内存的索引都必须清除

    //否则内存中的元素依然可以被访问

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

    elements[i] = null;

    }

    //动态数组的使用过程中可能会反复的添加或删除元素,因此没有必要每次清空元素的时候都销毁数组所在的内存空间

    //因为申请和销毁内存空间都是需要时间的

    size = 0;

    }

    /**

    * 元素的数量

    * @return

    */

    public int size() {

    return size;

    }

    /**

    * 是否为空

    * @return

    */

    public boolean isEmpty() {

    return size == 0;

    }

    /**

    * 是否包含某个元素

    * @param element

    * @return

    */

    public boolean contains(E element) {

    return indexOf(element) != ELEMENT_NOT_FOUND;

    }

    /**

    * 添加元素到尾部

    * @param element

    */

    public void add(E element) {

    add(size, element);

    }

    /**

    * 获取index位置的元素

    * @param index

    * @return

    */

    public E get(int index) {

    rangeCheck(index);

    return elements[index];

    }

    /**

    * 设置index位置的元素

    * @param index

    * @param element

    * @return 原来的元素ֵ

    */

    public E set(int index, E element) {

    rangeCheck(index);

    E old = elements[index];

    elements[index] = element;

    return old;

    }

    /**

    * 在index位置插入一个元素

    * @param index

    * @param element

    */

    public void add(int index, E element) {

    //加这一行不允许存空值

    //if(element==null)return;

    //在插入元素之前先要判断输入的索引位置

    rangeCheckForAdd(index);

    ensureCapacity(size + 1);

    for (int i = size; i > index; i--) {

    elements[i] = elements[i - 1];

    }

    elements[index] = element;

    size++;

    }

    /**

    * 删除index位置的元素

    * @param index

    * @return

    */

    public E remove(int index) {

    rangeCheck(index);

    E old = elements[index];

    //需要往前挪的元素是index后一个到数组的最后一个

    for (int i = index + 1; i < size; i++) {

    elements[i - 1] = elements[i];

    }

    //size-1,之后将末尾的元素清空

    elements[--size] = null;

    return old;

    }

    /**

    * 查看元素的索引

    * @param element

    * @return

    */

    public int indexOf(E element) {

    if (element == null) { // 1

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

    if (elements[i] == null) return i;

    }

    } else {

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

    //判断相等的时候使用==是比较内存地址是否相等

    if (element.equals(elements[i])) return i; // n

    }

    }

    return ELEMENT_NOT_FOUND;

    }

    //public int indexOf2(E element) {

    //for (int i = 0; i < size; i++) {

    //if (valEquals(element, elements[i])) return i; // 2n

    //}

    //return ELEMENT_NOT_FOUND;

    //}

    //

    //private boolean valEquals(Object v1, Object v2) {

    //return v1 == null ? v2 == null : v1.equals(v2);

    //}

    /**

    * 保证要有capacity的容量

    * @param capacity

    */

    private void ensureCapacity(int capacity) {

    int oldCapacity = elements.length;

    if (oldCapacity >= capacity) return;

    // 新容量为旧容量的1.5倍

    int newCapacity = oldCapacity + (oldCapacity >> 1);

    E[] newElements = (E[]) new Object[newCapacity];

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

    newElements[i] = elements[i];

    }

    elements = newElements;

    System.out.println(oldCapacity + "扩容为" + newCapacity);

    }

    private void outOfBounds(int index) {

    throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);

    }

    private void rangeCheck(int index) {

    if (index < 0 || index >= size) {

    outOfBounds(index);

    }

    }

    private void rangeCheckForAdd(int index) {

    //插入元素的时候可以大于数组的现有长度

    if (index < 0 || index > size) {

    outOfBounds(index);

    }

    }

    @Override

    public String toString() {

    // size=3, [99, 88, 77]

    StringBuilder string = new StringBuilder();

    string.append("size=").append(size).append(", [");

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

    if (i != 0) {

    string.append(", ");

    }

    string.append(elements[i]);

    //if (i != size - 1) {

    //string.append(", ");

    //}

    }

    string.append("]");

    return string.toString();

    }

    }

    展开全文
  • 主要介绍了asp中使用redim、preserve创建动态数组实例,本文还给出了ASP中其它的数组操作例子,需要的朋友可以参考下
  • C语言 用malloc()创建动态数组

    万次阅读 多人点赞 2019-02-26 21:51:02
    使用malloc()创建动态数组 当我们创建数组时,不允许在程序运行时选择数组的大小和分配内存。如果n是一个整形变量。 double a[n]; // C99以前不允许,n是变量 但是,可以 a = (double *) malloc(n * sizeof(double...

    使用malloc()创建动态数组

    因本人才疏学浅,见识浅薄,有不当之处望指正,谢谢!

    当我们创建数组时,不允许在程序运行时选择数组的大小和分配内存。如果n是一个整形变量。

    double a[n];		// C99以前不允许,n是变量
    

    但是,可以

    a = (double *) malloc(n * sizeof(double));		// 允许
    

    关于内存分配。所有程序都必须预留足够多内存储存程序使用的数据。这些内存有的是自动分配。比如,下面声明:

    float a;
    char words[] = "Let's study the C language!";
    

    为一个float类型的值和一个字符串预留了足够的内存,或者可以显式指定分配一定数量的内存;

    int number[100];
    

    该声明预留了100个内存位置,每个位置都用于储存int类型的值。
    静态数据在程序载入内存时分配,而自动数据在程序执行块时分配,并在程序离开该块时释放。

    C语言可以做更多,可以在程序运行时分配更多的内存。主要是malloc()函数,
    malloc()函数原型:

    extern void *malloc
    

    该函数接受一个参数:所需的内存字节数。malloc()函数会找到合适的空闲内存块,这样的内存是匿名的。就是说,malloc()分配内存,不会为其赋名。但是,它确实返回动态分配内存块的首字节地址。可以把该地址赋给指针变量,并使用指针访问这块内存。

    我们用malloc()创建一个数组。除了用malloc()在程序运行时请求一块内存,还需要一个指针记录这块内存的位置。比如:

    double * a;
    a = (double *) malloc(30 * sizeof(double));
    

    应该坚持使用强制类型转换,提高代码的可读性。
    以上代码为30个double类型的值请求内存空间,并设置a指向该位置。指针a指向一个double类型,不是指向内含30个double类型值的块。

    malloc()和free()配套使用
    free()将内存归还内存池
    malloc()和free()的原型都在stdlib.h头文件中
    使用malloc(),程序可以在运行时才确定数组大小。如下:

    // dyn_arr -- 动态分配数组
    #include <stdio.h>
    #include <stdlib.h>			// 为malloc(), free()提供原型
    
    int main(void)
    {
    	double * a;
    	int max;
    	int number;
    	int i = 0;
    	printf("What is the maximum number of type double entries?\n");
    	if(scanf("%d", &max) != 1)
    	{
    		printf("Number not correctly entered -- bye.\n");
    		exit(EXIT_FAILURE);
    	}
    	a = (double *) malloc(max * sizeof(double));
    	if(a == NULL)
    	{
    		printf("Memory allocation failed. Goodbye.\n");
    		exit(EXIT_FAILURE);
    	}
    	// a 现在指向有max个元素的数组
    	printf("Enter the values (q to quit):\n");
    	while(i < max && scanf("%lf", &a[i]) == 1)
    		++i;
    	printf("Here are your %d entries:\n", number = i);
    	for(i = 0; i < number; i++)
    	{
    		printf("%7.2f ", a[i]);
    		if(i % 7 == 6)
    			printf("\n");
    	}
    	if(i % 7 != 0)
    		printf("\n");
    	printf("Done.\n");
    	free(a);
    
    	return 0;
    }
    

    如图:
    在这里插入图片描述
    输入6个数:
    在这里插入图片描述
    虽然输入6个数,但是程序也只处理前5个数

    展开全文
  • 用C语言创建动态数组

    2012-07-23 10:11:35
    本文讲述了如何用C语言也能创建动态数组的技巧,通过代码实例来演示分析,让你进一步了解数组的动态创建技巧与代码的艺术。
  • C++ 创建动态数组

    2015-01-17 19:12:48
    c语言创建动态数组: int *p = (int *)malloc(n * sizeof(int)); free(p); c++创建动态数组: int *pia = new int[n];//内置类型没有初始化 string *psa = new string[10];//默认的构造函数初始化 int *pia2...
  • 如何在vc中创建动态数组建立一维的,二维的,动态数组
  • 严格来说,C语言中并没有直接创建动态数组的方法。 但在 stdlib 库中提供了 几个创建动态存储区的函数,通过调用这些函数, 可以让我们实现创建动态数组的效果。 下面分别介绍每个函数的使用方法: 1. void *malloc...
  • 使用new创建动态数组

    2019-09-30 11:31:17
    使用new创建动态数组 例如: 1 int *psome=new int[10]; 要将数组的类型和元素的数目告诉new即可。 new运算符返回第一个元素的地址。 当程序使用完new分配的内存块时,要使用delete释放。 1 delete[]...
  • 据我所知,Python中的list类型是一个动态指针数组,当向其追加项时,它将增加其容量。NumPy中的数组使用一个连续的内存...我可以创建一个类,将NumPy数组包装在其中,并在该数组满时调整其大小,例如:class Dynami...
  • ca32a_demo_c++创建动态数组20200127 静态是在堆栈上创建的,动态实在堆(heap)上创建的 堆(heap)-自由存储区(free store)-内存的一个区域 c语言:malloc创建和free释放 c++语言:new和delete() 动态数组的定义...
  • 创建动态数组: 1.自定义接口,即想实现的方法。 public interface MyList { //添加元素 public void add(int data); //删除元素 public int remove(int index); //获取元素 public int get(int index...
  • 使用new来创建动态数组 在编译时给数组分配内存被称为静态联编static binding,意味着数组是在编译时加入到程序中的。但使用new时,如果在运行阶段需要数组,则创建它;如果不需要,则不创建。可以在程序运行时选择...
  • 1.使用new创建动态数组 为数组分配内存的通用格式如下: type_name* pointer_name = new type_naem [nums_elements]; 在C++中,创建动态数组很容易;只要将数组的元素类型和元素数目告诉new即可。必须在类型名后...
  • C++ C++ Builder中创建动态数组,分配内存,和C中类似。
  • C语言 创建动态数组的两种方法

    万次阅读 2019-02-27 15:13:02
    创建动态数组有两种方法 因本人才疏学浅,见识浅薄,有不当之处望指正,谢谢! 声明指针,调用malloc(), 将其返回值赋给指针,使用指针访问数组的元素。而且这个指针可以是静态或者自动的 声明变长数组(VLA),c99新...
  • 使用Java中ArrayList创建动态数组 代码及解释如下: //用户向数组内输入并且最后将输入的数组遍历出来 使用动态数组ArrayList public static void shuru(){ //单独写了个方法存放动态数组,这里不用管 //创建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,543
精华内容 3,417
关键字:

创建动态数组