vc 创建动态数组
动态数组实验报告
一、实验目的1. 理解动态数组的概念和特点。
2. 掌握动态数组的创建、访问、修改和删除方法。
3. 熟悉动态数组的内存管理。
4. 深入了解动态数组在实际编程中的应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 编译器：Visual Studio 2019三、实验原理动态数组是一种在运行时可以根据需要动态调整大小的数组。
它允许程序在不知道数组元素个数的情况下，动态地创建和修改数组的大小。
动态数组在内存中占用连续的存储空间，但与静态数组相比，动态数组的大小可以根据需要动态调整。
四、实验内容1. 动态数组的创建与初始化实验步骤：（1）包含头文件：#include <iostream>（2）定义动态数组：int dynamicArray = new int[10];（3）初始化动态数组：for (int i = 0; i < 10; ++i) dynamicArray[i] = i 2;2. 动态数组的访问与修改实验步骤：（1）访问动态数组元素：int value = dynamicArray[5];（2）修改动态数组元素：dynamicArray[2] = 100;3. 动态数组的内存管理实验步骤：（1）释放动态数组内存：delete[] dynamicArray;（2）创建新的动态数组：int newArray = new int[20];（3）复制旧动态数组到新动态数组：for (int i = 0; i < 10; ++i) newArray[i] = dynamicArray[i];（4）释放旧动态数组内存：delete[] dynamicArray;4. 动态数组的应用实验步骤：（1）定义动态数组：int numbers = new int[10];（2）从用户输入中读取数据并填充动态数组：for (int i = 0; i < 10; ++i) std::cin >> numbers[i];（3）对动态数组进行排序：for (int i = 0; i < 10; ++i) for (int j = i + 1; j < 10; ++j) if (numbers[i] > numbers[j]) std::swap(numbers[i],numbers[j]);（4）输出排序后的动态数组：for (int i = 0; i < 10; ++i) std::cout << numbers[i] << " ";五、实验结果与分析1. 动态数组的创建与初始化：成功创建一个大小为10的动态数组，并成功初始化。
C语言中动态数组的实现
C语言中动态数组的实现在C语言中，动态数组的实现主要依靠指针和内存分配函数。
动态数组是在程序执行过程中根据需要动态分配内存空间的数组。
相比于静态数组，在编写代码时不需要提前指定数组的大小，可以更加灵活地适应不同数据量的需求。
C语言中的动态数组实现主要分为两个步骤：内存分配和内存释放。
1.内存分配：C语言提供了几种内存分配函数来动态分配内存空间，包括malloc、calloc、realloc等。
a) malloc函数：malloc函数用于从堆中分配指定大小的内存块，并返回该内存块的首地址。
其函数原型为：```cvoid* malloc(size_t size);```这里的size是以字节为单位的分配内存的大小。
分配成功时，返回分配内存的首地址；分配失败时，返回NULL。
b) calloc函数：calloc函数用于从堆中分配指定数量、指定大小的连续内存空间，并将该内存空间初始化为0。
其函数原型为：```cvoid* calloc(size_t num, size_t size);```这里的num是要分配的元素个数，size是每个元素的大小。
分配成功时，返回分配内存的首地址；分配失败时，返回NULL。
c) realloc函数：realloc函数用于重新调整之前分配的内存大小，并返回调整后的内存地址。
其函数原型为：```cvoid* realloc(void* ptr, size_t size);```这里的ptr是之前分配的内存地址，size是调整后的内存大小。
如果调整成功，返回调整后的内存地址；如果调整失败，返回NULL。
2.内存释放：动态数组使用完毕后，需要手动释放分配的内存空间，避免内存泄漏。
C语言中使用free函数来释放动态分配的内存空间，函数原型为：```cvoid free(void* ptr);```这里的ptr为之前分配的内存地址。
释放成功后，内存空间可以被重新分配使用；如果指针为空指针，则不进行任何操作。
cc++动态申请数组
cc++动态申请数组new和delete运算符⽤于动态分配和撤销内存的运算符new使⽤⽅法:1. 开辟单变量地址空间1)new int; //开辟⼀个存放数组的存储空间,返回⼀个指向该存储空间的地址.int *a = new int 即为将⼀个int类型的地址赋值给整型指针a.2)int *a = new int(5) 作⽤同上,可是同⼀时候将整数赋值为52. 开辟数组空间⼀维: int *a = new int[100];开辟⼀个⼤⼩为100的整型数组空间⼆维: int **a = new int[5][6]三维及其以上:依此类推.⼀般使⽤⽅法: new 类型 [初值]delete使⽤⽅法:1. int *a = new int;delete a; //释放单个int的空间2.int *a = new int[5];delete [] a; //释放int数组空间要訪问new所开辟的结构体空间,⽆法直接通过变量名进⾏,仅仅能通过赋值的指针进⾏訪问.⽤new和delete能够动态开辟,撤销地址空间.在编程序时,若⽤完⼀个变量(通常是临时存储的数组),下次须要再⽤,但却⼜想省去⼜⼀次初始化的功夫,能够在每次開始使⽤时开辟⼀个空间,在⽤完后撤销它.#include <iostream>using namespace std;int main(){char *p=new char[10];scanf ("%s",p);printf ("%s",p);delete []p;while (1);return 0;}这是⼆维数组的申请⽅法#define ROW 100#define COL 200#define T char (int,float,....) //通⽤数据类型T ** pTemp ;*pTemp = new T[ROW] ;for (int i = 0 ; i < COL ; i ++)pTemp[i] = new T[COL};/////////////////deletefor (int i =0 ; i < COL ; i ++)delete [] pTemp[i] ;delete [][]pTemp ;1.分配内存空间函数malloc 调⽤形式： (类型说明符*) malloc (size) 功能：在内存的动态存储区中分配⼀块长度为"size" 字节的连续区域。
C语言宏定义技巧和实现动态数组
20，宏定义防止使用是错误 用小括号包含。 例如：#define ADD(a,b) （a+b）
用 do{}while(0)语句包含多语句防止错误
例如：#difne DO(a,b) a+b;\
应用时：if(….)
a++;
DO(a,b); //产生错误
_FILE_ _DATE_ _TIME_ _STDC_ 如果编译不是标准的，则可能仅支持以上宏名中的几个，或根本不支持。记住编译程序 也许还提供其它预定义的宏名。 _ L I N E _及_ F I L E _宏指令在有关# l i n e 的部分中已讨论，这里讨论其余的宏名。 _ D AT E _宏指令含有形式为月/日/年的串，表示源文件被翻译到代码时的日期。 源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时：分：秒。 如果实现是标准的，则宏_ S T D C _含有十进制常量 1。如果它含有任何其它数，则实现是 非标准的。 可以定义宏，例如: 当定义了_DEBUG，输出数据信息和所在文件所在行 #ifdef _DEBUG #define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_) #else
//下面的不建议使用 typedef unsigned char byte; typedef unsigned short word;
/* Unsigned 8 bit value type. */ /* Unsinged 16 bit value type. */
typedef unsigned long dword;
动态数组c语言
动态数组c语言
动态数组是一种在程序运行期间可以动态增加或缩减大小的数组。
在C语言中，动态数组可以通过指针和指针算术来实现。
与静态数组相比，动态数组具有以下优点：
1.灵活性更高：动态数组的大小可以根据需要进行增加或缩减，因此可以适应不同的数据处理需求。
2.节省内存空间：由于动态数组是在程序执行期间分配内存空间，因此可以避免静态数组因为定义时已经分配了大量内存空间而造成空间浪费。
3.更为安全：动态数组可以避免静态数组因为数组越界而产生异常，从而保证程序的稳定性。
在C语言中，动态数组的实现可以借助于指针和动态内存分配函数。
以下是一个简单的动态数组示例，用于演示如何使用动态数组：
#include <stdio.h>
#include <stdlib.h>
在上面的程序中，首先要求用户输入动态数组的大小num。
然后，通过malloc函数动态分配内存空间来存储整型数据类型。
在输入动态数组元素的过程中，可以使用指针和指针算术来访问数组的元素。
在累加输入的整数元素之后，使用free函数释放动态分配的内存空间，并将指针ptr设置为NULL以避免悬挂指针的情况。
C、C++之动态数组的实现
C、C++之动态数组的实现C、C++之动态数组的实现本篇博客基于笔者本⼈正在学习的C++上机课程作业，主要代码由C语⾔构成。
由于C语⾔没有 string 、vector、valarray等完善的类，所以在实现动态数组时，需要⾃⾏考虑内存的分配和管理，C语⾔中，对内存管理的函数如malloc、realloc、free等被包括在 < malloc .h >头⽂件中。
关于这些函数使⽤的具体实例，可以参考这篇⽂章：具体实现时，使⽤了某些 C++ 的特有语法，如在for循环⾥定义变量，这是C语⾔不允许的，但由于现有现有编译器⼀般都同时⽀持，因此不特别注明下⾯会贴出实验课上所⽤的测试代码，针对测试代码，可以发现，实现⼀个动态数组不难，因为已经有现成的函数可以调⽤，⽽针对数组的操作较多，需要逐⼀讨论测试⽂件如下：// LibArray.cpp : 定义控制台应⽤程序的⼊⼝点。
//// 实验内容：// 1：使⽤C语⾔实现⼀个长度可扩充的数组（包含必要的数据结构及函数）；// 2：要求能存放任意类型的数据（建议先实现存储整形的代码，之后改写成适应任意类型的代码）；// 3：所写程序需能通过测试程序// 4：除本⽂件（测试⽂件）之外，其他⽂件（如CLibArray.cpp及CLibArray.h⽂件）、以及⼯程由同学⾃⼰建⽴。
过程中可翻书，可查看msdn。
// 实验⽬的：// 1：熟悉相关的指针操作, 复习动态内存的相关操作.// 2：理解C程序如何实现数据类型和围绕数据类型上操作的集合// 3：为未来理解类实现的数组vector做准备// 只提交CLibArray.cpp及CLibArray.h#include "stdafx.h"#include <assert.h>#include<stdlib.h>#include "CLibArray.h"int _tmain(int argc, _TCHAR* argv[]){CArray array;array_initial(array);array_recap(array, 10);assert(array_capacity(array) == 10);//////////////////////////////////////////////////////////////////////////for (int i = 0; i < 20; ++i){array_append(array, i);}assert(array_size(array) == 20);for (int i = 0; i < array_size(array); ++i){assert(array_at(array, i) == i);}//////////////////////////////////////////////////////////////////////////CArray array2, array3;array_initial(array2);array_initial(array3);array_copy(array, array2);assert(array_compare(array, array2) == true);array_copy(array, array3);assert(array_compare(array, array3) == true);//////////////////////////////////////////////////////////////////////////array_insert(array2, 2, 3);assert(array_compare(array, array2) == false);//////////////////////////////////////////////////////////////////////////array_at(array3, 2) = 5;assert(array_compare(array, array3) == false);//////////////////////////////////////////////////////////////////////////array_destroy(array);array_destroy(array2);array_destroy(array3);return 0;}可以看出，⾸先要确定 CArray 的具体类型，以 int 型为例，动态数组具有可变的容量（capacity，已分配空间）和实际⼤⼩（size，已使⽤的空间），⽽malloc等函数的参数要求都是指针，因此，可以把 CArray 定义为结构体：// defination of CArraytypedef struct CArray{int* arrayhead;int size;int capacity;}CArray;注意，在结构体中（c++中，结构体可以看做是简单的类），是不允许初始化普通成员的，因为上述代码只是给出此类型的定义，⽽没有定义实际的变量。
C语言建立动态数组
C语⾔建⽴动态数组C语⾔建⽴动态数组数组的有点在于随机存取，然⽽其不⾜也是明显的，就是⼀旦建⽴其⼤⼩就不能改变。
若⽤数组存储数据，则必须创建⼀个可能存放的最⼤空间的数组，这⽆疑浪费了空间。
动态数组解决了这个问题。
动态数组的思路是：先建⽴⼀定⼤⼩的数组，向这个数组中存放数据，如果数组已满，则重新申请⼀个更⼤的空间来存放。
每次重新申请时可以指定增量（inc）的⼤⼩，也可以固定⼤⼩。
这样做的好处是空间浪费不多，最多浪费（inc-1）个元素空间，其不⾜是重新申请空间浪费时间，每次重新申请空间时须将原来的数据拷贝到新申请的空间，当数组很⼤时，这种浪费还是相当可观的。
稍后将⽤链表和数组结合解决这⼀问题。
先建⽴动态数组的存储结构：typedef unsigned char BOOL;typedef int elem_t; //存放数据类型typedef struct{int iCount; //数据个数（数组中实际存放元素的个数）int iCapacity; //容量（数组中能够容纳元素的最⼤个数）elem_t * pData; //数据指针（该指针指向存放数据空间的⾸地址）}Array_t;下⾯定义数组的基本操作，包括：1、初始化；2、设置元素的值；3、取得元素的引⽤（C语⾔中指地址）；4、取得元素的值；5、销毁数组以下是上⾯五个操作的函数声明：BOOL initArray( Array_t * array, int size ); //初始化，size为指定初始化数组容量BOOL setValue( Array_t * array, int index, elem_t val ); //设置指定位置元素的值elem_t * getRef( Array_t * array, int index ); //得到指定位置元素的引⽤（地址）elem_t getValue( Array_t * array, int index ); //得到指定位置元素的值BOOL destroyArray( Array_t * array ); //销毁该数组以下是函数实现：#define INIT_DATA_NUM 10 //数组初始化⼤⼩，增量⼤⼩BOOL initArray( Array_t * array, int size ) //初始化,若size <= 0，则采⽤默认⼤⼩{BOOL bRet = FALSE;int initSize = (size > 0) ? size:INIT_DATA_NUM;array->pData = ( elem_t * )malloc( initSize * sizeof( elem_t) );if ( array->pData != NULL ){array->iCapacity = initSize;array->iCount = 0;bRet = TRUE;}return bRet;}BOOL setValue( Array_t * array, int index, elem_t val ) //设置指定位置元素的值{BOOL bRet = FALSE;if( index > 0 && index < array->iCount ){array->pData[index] = val;bRet = TRUE;}return bRet;}elem_t * getRef( Array_t * array, int index ) //得到指定位置元素的引⽤（地址）{elem_t * eRet = NULL;if( index > 0 && index < array->iCount ){eRet = array->pData + index;}return eRet;}elem_t getValue( Array_t * array, int index ) //得到指定位置元素的值(不检查数组越界){return array->pData[index];}BOOL destroyArray( Array_t * array ) //销毁该数组{free( array->pData );array->pData = NULL;return TRUE;}这样关于动态数组的基本操作就完成了。
【IT专家】创建一个动态数组,接受C中的任何类型
本文由我司收集整编，推荐下载，如有疑问，请与我司联系创建一个动态数组，接受C中的任何类型I’m trying to find a way to make a struct to hold a dynamic array that can work with any data type (Including user defined data types), so far this is what I came up with. 我正在尝试找到一种方法，使struct拥有一个能够处理任何数据类型(包括用户定义的数据类型)的动态数组，到目前为止，这就是我所想到的。
#define Vector(DATATYPE) struct { DATATYPE* data; size_t size; size_t used; }typedef Vector(int) int_Vector;int main(int argc, char* argv[]){ int_Vector vec; return 0; While this works I was wondering, is this good practice? Should I be doing something like this or is there a better method? Also is there a method to implement this with out the typedef Vector(int) int_vector part. Basically a way that would enable me to use the array the same way c++ uses templates where it would look something like this: 当这个有效的时候，我在想，这是一个好的实践吗?我应该做这样的事情还是有更好的方法?还有一种方法可以使用typedef Vector(int) int_vector部分来实现这一点。
c 动态结构体数组
c 动态结构体数组摘要：一、动态结构体数组的概念二、动态结构体数组的实现方法1.使用链表实现动态结构体数组2.使用vector 实现动态结构体数组3.自定义动态结构体数组类三、动态结构体数组的优缺点四、动态结构体数组的应用示例五、总结正文：一、动态结构体数组的概念动态结构体数组是一种在程序运行时可以自动调整大小、支持动态插入和删除元素的数据结构。
相较于传统的数组，动态结构体数组在处理不确定大小的数据时更具有灵活性。
二、动态结构体数组的实现方法1.使用链表实现动态结构体数组利用链表可以实现动态结构体数组。
具体实现如下：```cstruct Node {int data;Node* next;int main() {Node* head = NULL;int n = 10;for (int i = 0; i < n; ++i) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = i;newNode->next = head;head = newNode;}}```2.使用vector 实现动态结构体数组C++中的vector 也可以实现动态结构体数组。
具体实现如下：```cpp#include <vector>int main() {std::vector<int> vec;int n = 10;for (int i = 0; i < n; ++i) {vec.push_back(i);}```3.自定义动态结构体数组类还可以自定义一个动态结构体数组类来实现动态插入和删除元素。
具体实现如下：```cpp#include <iostream>#include <cstring>#include <cstdio>#include <algorithm>#include <cstdlib>#include <cassert>using namespace std;class DynamicArray {public:DynamicArray() : size(0), data(NULL) {}~DynamicArray() {delete[] data;}void insert(int index, int value) {if (index < 0 || index > size) {throw std::out_of_range("Index out of range");int newSize = (size + 1) * 2;int* newData = (int*)realloc(data, newSize * sizeof(int));for (int i = size; i > index; --i) {newData[i] = data[i - 1];}newData[index] = value;data = newData;size++;}void remove(int index) {if (index < 0 || index >= size) {throw std::out_of_range("Index out of range");}for (int i = index; i < size - 1; ++i) {data[i] = data[i + 1];}--size;}int get(int index) {if (index < 0 || index >= size) {throw std::out_of_range("Index out of range");return data[index];}private:int size;int* data;};int main() {DynamicArray arr;arr.insert(1, 10);arr.insert(0, 20);arr.insert(2, 30);std::cout << arr.get(0) << std::endl; // 输出20arr.remove(1);std::cout << arr.get(1) << std::endl; // 输出30}```三、动态结构体数组的优缺点动态结构体数组的优点是可以在程序运行时自动调整大小，支持动态插入和删除元素。
c语言 结构体中的动态数组
c语言结构体中的动态数组结构体是C语言中一种自定义的数据类型，可以将不同类型的变量组合在一起，形成一个新的数据类型。
结构体中的动态数组是指结构体中的某个成员是一个可变长度的数组。
在C语言中，我们可以使用动态内存分配函数malloc和free来创建和释放动态数组。
动态数组的长度可以在运行时根据需要进行调整，这为我们处理不确定长度的数据提供了便利。
动态数组的使用可以大大提高程序的灵活性和效率。
在结构体中使用动态数组可以解决静态数组长度固定的限制，使得结构体能够存储可变长度的数据。
在使用动态数组时，我们首先需要定义一个结构体，然后在结构体中声明一个指针类型的成员作为动态数组的指针。
接着我们可以使用malloc函数为数组分配内存空间，并将返回的指针赋值给结构体成员。
在使用完动态数组后，我们需要使用free函数释放内存空间，防止内存泄漏。
下面是一个使用动态数组的结构体示例：```#include <stdio.h>#include <stdlib.h>struct Student {char name[20];int age;int *scores;};int main() {struct Student student;printf("请输入学生姓名：");scanf("%s", );printf("请输入学生年龄：");scanf("%d", &student.age);int num;printf("请输入学生的科目数：");scanf("%d", &num);// 为动态数组分配内存空间student.scores = (int *)malloc(num * sizeof(int)); printf("请输入学生的成绩：");for (int i = 0; i < num; i++) {scanf("%d", &student.scores[i]);}printf("学生姓名：%s\n", );printf("学生年龄：%d\n", student.age);printf("学生的成绩：");for (int i = 0; i < num; i++) {printf("%d ", student.scores[i]);}printf("\n");// 释放内存空间free(student.scores);return 0;}```在上面的示例中，我们定义了一个结构体Student，其中包含了学生的姓名、年龄和成绩。
c 动态大小数组
c 动态大小数组C语言是一种广泛应用于系统程序设计和嵌入式开发的编程语言。
它的灵活性和高效性使得它成为许多开发者的首选语言。
在C语言中，动态大小数组是一种非常有用的数据结构，它可以在程序运行时动态地分配和释放内存空间，以适应不同的数据需求。
动态大小数组在C语言中的实现是通过指针和内存管理函数来完成的。
在C语言中，指针是一种特殊的变量类型，它存储了一个内存地址。
通过使用指针，我们可以动态地分配和释放内存空间，以创建和操作动态大小数组。
在C语言中，动态大小数组的实现通常涉及以下几个步骤：1. 定义指针变量：首先，我们需要定义一个指针变量来存储动态数组的起始地址。
例如，可以使用以下语句来定义一个指向整型数组的指针变量：int *arr;2. 分配内存空间：接下来，我们使用内存管理函数malloc来分配内存空间。
malloc函数接受一个参数，即所需的内存空间的大小（以字节为单位），并返回一个指向分配内存的指针。
例如，可以使用以下语句来分配一个包含5个整型元素的数组：arr = (int *)malloc(5 * sizeof(int));3. 访问数组元素：一旦内存空间分配完成，我们就可以使用指针来访问和操作数组元素。
例如，可以使用以下语句来给数组元素赋值：arr[0] = 10;arr[1] = 20;arr[2] = 30;arr[3] = 40;arr[4] = 50;4. 释放内存空间：当我们不再需要动态数组时，我们应该释放所分配的内存空间，以避免内存泄漏。
通过调用内存管理函数free，我们可以释放之前分配的内存空间。
例如，可以使用以下语句来释放动态数组的内存空间：free(arr);动态大小数组在C语言中的应用非常广泛。
它可以用于解决各种问题，例如动态存储用户输入的数据、动态存储读取的文件内容、动态管理大型数据集合等等。
通过使用动态大小数组，我们可以在程序运行时根据需要动态地分配和释放内存空间，以提高程序的灵活性和效率。
动态数组的创建和使用方法_Visual Basic程序设计案例教程_[共2页]
![动态数组的创建和使用方法_Visual Basic程序设计案例教程_[共2页]](https://img.taocdn.com/s3/m/18a96cdf763231126fdb113b.png)
Visual Basic 程序设计案例教程2188.5.1 动态数组的创建和使用方法声明数组时，只定义数组名称和数组元素的数据类型，但没有定义数组的维数和元素的个数，这样声明的数组就是动态数组。
使用动态数组时，必须在使用前用ReDim 语句重新声明。
从上述可知，创建动态数组的步骤如下。
（1）用dim 语句声明一个未指明大小及维数的数组格式：public | private | dim | static <数组名>( )as 类型说明符功能：定义动态数组的名称。
（2）用ReDim 语句声明动态数组的大小格式：ReDim [Preserve] <数组名>（<下标1的上界>[，<下标2的上界>]…[，<下标n 的上界>]）[as 类型说明符]例如，第一次在通用段中用语句dim a() as integer 声明动态数组a ，然后，在过程中给数组用ReDim 分配空间。
格式如下：通用段中输入语句dim a() as integer过程段中输入语句Private Sub Form_Load()．．．ReDim a(10,20)．．． End Sub这里的ReDim a(10,20)语句为上面声明的数组a()分配一个11×21的整数空间。
【例8-9】 根据输入的行数和列数，产生一个矩阵，并将原矩阵转置。
① 界面设计。
界面及属性设置同例8-8。
② 编写代码。
在通用段中声明数组：Option base 1Dim A( ) As IntegerDim m, n As IntegerCommand1（产生矩阵）按钮的Click 事件代码如下：Private Sub Command1_Click()m = Val(InputBox("输入矩阵的行数", "输入提示"))n = Val(InputBox("输入矩阵的列数", "输入提示"))ReDim A(m, n)RandomizePicture1.Print Tab(2); "原始" & m & "×" & n & "矩阵各元素:"Picture1.PrintFor i = 1 To mFor j = 1 To nA(i, j) = Int(Rnd * 90 + 10)Picture1.Print A(i, j);Next j。
C 二维动态数组的申请与_释放
一维数组是指针，可将二维数组看作是指针的指针：每一行是一个一维数组，而列是指向行的指针。
在动态创建时，先分配指向行的指针空间，再循环维每一行申请空间。
#include <iostream>using namespace std;int main(){//[3]4] //三行四列的二维数组int x,y;int i,n,k;x=3;y=4;int **p;p = new int*[x]; //行 //申请行的空间//每行的列申请空间for(i=0; i<x;i++){p[i] = new int [y];}//赋值，k=0;for(i=0;i<x;i++){for(n=0;n<y;n++){p[i][n] = k;k++;}}//显示刚才的赋值for(i=0;i<x;i++){for(n=0;n<y;n++){cout << p[i][n] << "\t";}cout << endl;}//删除刚才申请的内存for(i=0;i<x;i++){delete [] p[i];}delete [] p;return 0;今天归纳总结了一下，希望以后的朋友可以少走些弯路：）一：关于指针和堆的内存分配先来介绍一下指针：指针一种类型，理论上来说它包含其他变量的地址，因此有的书上也叫它：地址变量。
既然指针是一个类型，是类型就有大小，在达内的服务器上或者普通的ＰＣ机上，都是４个字节大小,里边只是存储了一个变量的地址而已。
不管什么类型的指针，char * ,int * ,int (*) ,string * ,float * ，都是说明了本指针所指向的地址空间是什么类型而已，了解了这个基本上所有的问题都好象都变的合理了。
在C++中，申请和释放堆中分配的存贮空间，分别使用new和delete的两个运算符来完成：指针类型指针变量名=new 指针类型 (初始化)；delete 指针名;例如：1、 int *p=new int(0);它与下列代码序列大体等价：2、int tmp=0, *p=&tmp;区别：p所指向的变量是由库操作符new()分配的，位于内存的堆区中，并且该对象未命名。
使用C语言实现vector动态数组的实例分享
使⽤C语⾔实现vector动态数组的实例分享下⾯是做项⽬时实现的⼀个动态数组，先后加⼊了好⼏个之后的项⽬，下⾯晒下代码。
头⽂件：# ifndef __CVECTOR_H__# define __CVECTOR_H__# define MIN_LEN 256# define CVEFAILED -1# define CVESUCCESS 0# define CVEPUSHBACK 1# define CVEPOPBACK 2# define CVEINSERT 3# define CVERM 4# define EXPANED_VAL 1# define REDUSED_VAL 2typedef void *citerator;typedef struct _cvector *cvector;# ifdef _cplusplus# define EXTERN_ extern "C"# else# define EXTERN_ extern# endifEXTERN_ cvector cvector_create (const size_t size );EXTERN_ void cvector_destroy (const cvector cv );EXTERN_ size_t cvector_length (const cvector cv );EXTERN_ int cvector_pushback (const cvector cv, void *memb );EXTERN_ int cvector_popback (const cvector cv, void *memb );EXTERN_ size_t cvector_iter_at (const cvector cv, citerator iter );EXTERN_ int cvector_iter_val (const cvector cv, citerator iter, void *memb);EXTERN_ citerator cvector_begin (const cvector cv );EXTERN_ citerator cvector_end (const cvector cv );EXTERN_ citerator cvector_next (const cvector cv, citerator iter );EXTERN_ int cvector_val_at (const cvector cv, size_t index, void *memb );EXTERN_ int cvector_insert (const cvector cv, citerator iter, void *memb);EXTERN_ int cvector_insert_at(const cvector cv, size_t index, void *memb );EXTERN_ int cvector_rm (const cvector cv, citerator iter );EXTERN_ int cvector_rm_at (const cvector cv, size_t index );/* for test */EXTERN_ void cv_info (const cvector cv );EXTERN_ void cv_print (const cvector cv );#endif /* EOF file cvector.h */C⽂件：# include <stdio.h># include <stdlib.h># include <string.h># include <unistd.h># define MIN_LEN 256# define CVEFAILED -1# define CVESUCCESS 0# define CVEPUSHBACK 1# define CVEPOPBACK 2# define CVEINSERT 3# define CVERM 4# define EXPANED_VAL 1# define REDUSED_VAL 2typedef void *citerator;typedef struct _cvector{void *cv_pdata;size_t cv_len, cv_tot_len, cv_size;if ((cvector_begin(cv) > iter) || (cvector_end(cv) <= iter)) {\fprintf(stderr, "var(" #iter ") warng out of range, "\"at file:%s func:%s line:%d!!/n", file, func, line);\return CVEFAILED;\}\} while (0)# ifdef _cplusplus# define EXTERN_ extern "C"# else# define EXTERN_ extern# endifEXTERN_ cvector cvector_create (const size_t size );EXTERN_ void cvector_destroy (const cvector cv );EXTERN_ size_t cvector_length (const cvector cv );EXTERN_ int cvector_pushback (const cvector cv, void *memb ); EXTERN_ int cvector_popback (const cvector cv, void *memb ); EXTERN_ size_t cvector_iter_at (const cvector cv, citerator iter ); EXTERN_ int cvector_iter_val (const cvector cv, citerator iter, void *memb); EXTERN_ citerator cvector_begin (const cvector cv );EXTERN_ citerator cvector_end (const cvector cv );EXTERN_ citerator cvector_next (const cvector cv, citerator iter ); EXTERN_ int cvector_val_at (const cvector cv, size_t index, void *memb ); EXTERN_ int cvector_insert (const cvector cv, citerator iter, void *memb); EXTERN_ int cvector_insert_at(const cvector cv, size_t index, void *memb ); EXTERN_ int cvector_rm (const cvector cv, citerator iter );EXTERN_ int cvector_rm_at (const cvector cv, size_t index );/* for test */EXTERN_ void cv_info (const cvector cv );EXTERN_ void cv_print (const cvector cv );cvector cvector_create(const size_t size){cvector cv = (cvector)malloc(sizeof (struct _cvector));if (!cv) return NULL;cv->cv_pdata = malloc(MIN_LEN * size);if (!cv->cv_pdata){free(cv);return NULL;}cv->cv_size = size;cv->cv_tot_len = MIN_LEN;cv->cv_len = 0;return cv;}void cvector_destroy(const cvector cv){free(cv->cv_pdata);free(cv);return;}size_t cvector_length(const cvector cv){return cv->cv_len;}int cvector_pushback(const cvector cv, void *memb){if (cv->cv_len >= cv->cv_tot_len){void *pd_sav = cv->cv_pdata;cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);cv->cv_pdata = pd_sav;cv->cv_tot_len >>= EXPANED_VAL;return CVEPUSHBACK;}}memcpy(cv->cv_pdata + cv->cv_len * cv->cv_size, memb, cv->cv_size); cv->cv_len++;return CVESUCCESS;}int cvector_popback(const cvector cv, void *memb){if (cv->cv_len <= 0) return CVEPOPBACK;cv->cv_len--;memcpy(memb, cv->cv_pdata + cv->cv_len * cv->cv_size, cv->cv_size); if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))&& (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL))){void *pd_sav = cv->cv_pdata;cv->cv_tot_len >>= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = pd_sav;return CVEPOPBACK;}}return CVESUCCESS;}size_t cvector_iter_at(const cvector cv, citerator iter){CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);return (iter - cv->cv_pdata) / cv->cv_size;}int cvector_iter_val(const cvector cv, citerator iter, void *memb){CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);memcpy(memb, iter, cv->cv_size);return 0;}citerator cvector_begin(const cvector cv){return cv->cv_pdata;}citerator cvector_end(const cvector cv){return cv->cv_pdata + (cv->cv_size * cv->cv_len);}static inline void cvmemove_foreward(const cvector cv, void *from, void *to) {size_t size = cv->cv_size;void *p;for (p = to; p >= from; p -= size) memcpy(p + size, p, size);return;}static inline void cvmemove_backward(const cvector cv, void *from, void *to) {memcpy(from, from + cv->cv_size, to - from);return;}CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);if (cv->cv_len >= cv->cv_tot_len){void *pd_sav = cv->cv_pdata;cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_pdata = pd_sav;cv->cv_tot_len >>= EXPANED_VAL;return CVEINSERT;}}cvmemove_foreward(cv, iter, cv->cv_pdata + cv->cv_len * cv->cv_size);memcpy(iter, memb, cv->cv_size);cv->cv_len++;return CVESUCCESS;}int cvector_insert_at(const cvector cv, size_t index, void *memb){citerator iter;if (index >= cv->cv_tot_len){cv->cv_len = index + 1;while (cv->cv_len >= cv->cv_tot_len) cv->cv_tot_len <<= EXPANED_VAL; cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);iter = cv->cv_pdata + cv->cv_size * index;memcpy(iter, memb, cv->cv_size);}else{iter = cv->cv_pdata + cv->cv_size * index;cvector_insert(cv, iter, memb);}return 0;}citerator cvector_next(const cvector cv, citerator iter){return iter + cv->cv_size;}int cvector_val(const cvector cv, citerator iter, void *memb){memcpy(memb, iter, cv->cv_size);return 0;}int cvector_val_at(const cvector cv, size_t index, void *memb){memcpy(memb, cv->cv_pdata + index * cv->cv_size, cv->cv_size);return 0;}int cvector_rm(const cvector cv, citerator iter){citerator from;citerator end;CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);from = iter;end = cvector_end(cv);memcpy(from, from + cv->cv_size, end - from);cv->cv_len--;if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))&& (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL)))cv->cv_tot_len >>= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = pd_sav;return CVERM;}}return CVESUCCESS;}int cvector_rm_at(const cvector cv, size_t index){citerator iter;iter = cv->cv_pdata + cv->cv_size * index;CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);return cvector_rm(cv, iter);}void cv_info(const cvector cv){printf("/n/ntot :%s : %d/n", __func__, cv->cv_tot_len);printf("len :%s : %d/n", __func__, cv->cv_len);printf("size:%s : %d/n/n", __func__, cv->cv_size);return;}void cv_print(const cvector cv){int num;citerator iter;if (cvector_length(cv) == 0)fprintf(stderr, "file:%s func:%s line:%d error, null length cvector!!/n", __FILE__, __func__, __LINE__);for (iter = cvector_begin(cv);iter != cvector_end(cv);iter = cvector_next(cv, iter)){cvector_iter_val(cv, iter, &num);printf("var:%d at:%d/n", num, cvector_iter_at(cv, iter));}return;}改进版上⾯那份代码是在Linux下写的，如果是在Windows的Visul C++环境下编译似乎会出些问题，所以特别做了个改进版：下⾯是更新后的代码：cvector.h# ifndef __CVECTOR_H__# define __CVECTOR_H__# include <stdio.h># include <stdlib.h># include <string.h># define MIN_LEN 256# define CVEFAILED -1# define CVESUCCESS 0# define CVEPUSHBACK 1# define CVEPOPBACK 2# define CVEINSERT 3# define CVERM 4# define EXPANED_VAL 1# define REDUSED_VAL 2# ifdef __cplusplusextern "C" {# endifcvector cvector_create (const size_t size );void cvector_destroy (const cvector cv );size_t cvector_length (const cvector cv );int cvector_pushback (const cvector cv, void *memb );int cvector_popback (const cvector cv, void *memb );size_t cvector_iter_at (const cvector cv, citerator iter );int cvector_iter_val (const cvector cv, citerator iter, void *memb); citerator cvector_begin (const cvector cv );citerator cvector_end (const cvector cv );citerator cvector_next (const cvector cv, citerator iter );int cvector_val_at (const cvector cv, size_t index, void *memb ); int cvector_insert (const cvector cv, citerator iter, void *memb); int cvector_insert_at(const cvector cv, size_t index, void *memb ); int cvector_rm (const cvector cv, citerator iter );int cvector_rm_at (const cvector cv, size_t index );/* for test */void cv_info (const cvector cv );void cv_print (const cvector cv );# ifdef __cplusplus}# endif#endif /* EOF file cvector.h */cvector.c#include "cvector.h"#ifndef __gnu_linux__#define __func__ "unknown"#define inline __forceinline#endif# define CWARNING_ITER(cv, iter, file, func, line) \do {\if ((cvector_begin(cv) > iter) || (cvector_end(cv) <= iter)) {\fprintf(stderr, "var(" #iter ") warng out of range, "\"at file:%s func:%s line:%d!!\n", file, func, line);\return CVEFAILED;\}\} while (0)struct _cvector{void *cv_pdata;size_t cv_len, cv_tot_len, cv_size;};cvector cvector_create(const size_t size){cvector cv = (cvector)malloc(sizeof (struct _cvector));if (!cv) return NULL;cv->cv_pdata = malloc(MIN_LEN * size);if (!cv->cv_pdata){free(cv);return NULL;}cv->cv_size = size;cv->cv_tot_len = MIN_LEN;cv->cv_len = 0;void cvector_destroy(const cvector cv){free(cv->cv_pdata);free(cv);return;}size_t cvector_length(const cvector cv){return cv->cv_len;}int cvector_pushback(const cvector cv, void *memb){if (cv->cv_len >= cv->cv_tot_len){void *pd_sav = cv->cv_pdata;cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_pdata = pd_sav;cv->cv_tot_len >>= EXPANED_VAL;return CVEPUSHBACK;}}memcpy((char *)cv->cv_pdata + cv->cv_len * cv->cv_size, memb, cv->cv_size); cv->cv_len++;return CVESUCCESS;}int cvector_popback(const cvector cv, void *memb){if (cv->cv_len <= 0) return CVEPOPBACK;cv->cv_len--;memcpy(memb, (char *)cv->cv_pdata + cv->cv_len * cv->cv_size, cv->cv_size); if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))&& (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL))){void *pd_sav = cv->cv_pdata;cv->cv_tot_len >>= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = pd_sav;return CVEPOPBACK;}}return CVESUCCESS;}size_t cvector_iter_at(const cvector cv, citerator iter){CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);return ((char *)iter - (char *)cv->cv_pdata) / cv->cv_size;}int cvector_iter_val(const cvector cv, citerator iter, void *memb){CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);memcpy(memb, iter, cv->cv_size);return 0;}citerator cvector_begin(const cvector cv){citerator cvector_end(const cvector cv){return (char *)cv->cv_pdata + (cv->cv_size * cv->cv_len);}static inline void cvmemove_foreward(const cvector cv, void *from, void *to) {size_t size = cv->cv_size;char *p;for (p = (char *)to; p >= (char *)from; p -= size) memcpy(p + size, p, size);return;}static inline void cvmemove_backward(const cvector cv, void *from, void *to) {memcpy(from, (char *)from + cv->cv_size, (char *)to - (char *)from);return;}int cvector_insert(const cvector cv, citerator iter, void *memb){CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);if (cv->cv_len >= cv->cv_tot_len){void *pd_sav = cv->cv_pdata;cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_pdata = pd_sav;cv->cv_tot_len >>= EXPANED_VAL;return CVEINSERT;}}cvmemove_foreward(cv, iter, (char *)cv->cv_pdata + cv->cv_len * cv->cv_size); memcpy(iter, memb, cv->cv_size);cv->cv_len++;return CVESUCCESS;}int cvector_insert_at(const cvector cv, size_t index, void *memb){citerator iter;if (index >= cv->cv_tot_len){cv->cv_len = index + 1;while (cv->cv_len >= cv->cv_tot_len) cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);iter = (char *)cv->cv_pdata + cv->cv_size * index;memcpy(iter, memb, cv->cv_size);}else{iter = (char *)cv->cv_pdata + cv->cv_size * index;cvector_insert(cv, iter, memb);}return 0;}citerator cvector_next(const cvector cv, citerator iter){return (char *)iter + cv->cv_size;}int cvector_val(const cvector cv, citerator iter, void *memb){memcpy(memb, iter, cv->cv_size);int cvector_val_at(const cvector cv, size_t index, void *memb){memcpy(memb, (char *)cv->cv_pdata + index * cv->cv_size, cv->cv_size);return 0;}int cvector_rm(const cvector cv, citerator iter){citerator from;citerator end;CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);from = iter;end = cvector_end(cv);memcpy(from, (char *)from + cv->cv_size, (char *)end - (char *)from);cv->cv_len--;if ((cv->cv_tot_len >= (MIN_LEN << REDUSED_VAL))&& (cv->cv_len <= (cv->cv_tot_len >> REDUSED_VAL))){void *pd_sav = cv->cv_pdata;cv->cv_tot_len >>= EXPANED_VAL;cv->cv_pdata = realloc(cv->cv_pdata, cv->cv_tot_len * cv->cv_size);if (!cv->cv_pdata){cv->cv_tot_len <<= EXPANED_VAL;cv->cv_pdata = pd_sav;return CVERM;}}return CVESUCCESS;}int cvector_rm_at(const cvector cv, size_t index){citerator iter;iter = (char *)cv->cv_pdata + cv->cv_size * index;CWARNING_ITER(cv, iter, __FILE__, __func__, __LINE__);return cvector_rm(cv, iter);}void cv_info(const cvector cv){printf("\n\ntot :%s : %d\n", __func__, cv->cv_tot_len);printf("len :%s : %d\n", __func__, cv->cv_len);printf("size:%s : %d\n\n", __func__, cv->cv_size);return;}void cv_print(const cvector cv){int num;citerator iter;if (cvector_length(cv) == 0)fprintf(stderr, "file:%s func:%s line:%d error, null length cvector!!\n", __FILE__, __func__, __LINE__); for (iter = cvector_begin(cv);iter != cvector_end(cv);iter = cvector_next(cv, iter)){cvector_iter_val(cv, iter, &num);printf("var:%d at:%d\n", num, cvector_iter_at(cv, iter));}return;}main.cppint i = 1;cvector cv = cvector_create(sizeof(int)); cvector_pushback(cv, &i);cvector_pushback(cv, &i);cvector_pushback(cv, &i);cvector_pushback(cv, &i);cv_print(cv);cvector_destroy(cv);return 0;}。
vc++6.0中动态数组实现(例如string类对象数组等)
VC动态数组实现数组类型的变量有三个重要的限制:数组长度固定不变,在编译时必须知道其长度,数组只在定义它的块语句内存在.实际的程序往往不能忍受这样的限制-------它们需要在运行时动态地分配数组.虽然数组长度是固定的,但动态分配的数组不必在编译时知道其长度,可以(通常也是)在运行时才确定数组长度.与数组变量不同,动态分配的数组将一直存在,知道程序显式释放它为止.每一个程序在执行时都占用一款可用的内存空间,用于存放动态分配的对象,此内存空间称为程序的自由存储区(free store)或堆(heap).C语言程序使用一对标准库函数malloc和free在自由存储区中分配存储空间,而C++语言则使用new 和delete表达式实现相同的功能。
1.动态数组的定义数组变量通过指定类型、数组名和维数来定义.而动态分配数组时,只需指定类型和数组长度,不必为数组对象命名,new表达式返回指向新分配数组的第一个元素的指针:int *pia=new int[10]; //array of 10 uninitialized ints此new表达式分配了一个含有10个int型元素的数组,并返回指向该数组第一个元素的指针,此返回值初始化了之怎pia.new表达式需要指定指针类型以及在方括号中给出的数组维数,该维数可以是任意的复杂表达式.创建数组后,new将返回指向数组第一个元素的指针.在自由存储区中创建的数组对象是没有名字的,程序员只能通过其地址间接地访问堆中的对象.2.初始化动态分配的数组动态分配数组时,如果数组元素具有类类型,将使用该类的默认构造函数实现初始化;如果数组元素是内置类型,则无初始化:string *psa=new string[10]; //array of 10 empty stringsint *pia=new int[10]; //array of 10 ninitialized ints这两个new表达式都分配了含有10个对象的数组.其中第一个数组是string类型,分配了保存对象的内存空间后,将调用string类型的默认构造函数依次初始化数组中的每个元素(实际上string对象都是空串，结尾无‘\0’).第二个数组则具有内置类型的元素,分配了存储10个int对象的内存空间,但这些元素没有初始化.也可使用跟在数组长度后面的一对空圆括号,对数组元素做值初始化:int *pia2=new int[10](); //array of 10 uninitialized ints圆括号要求编译器对数组做值初始化,在本例中即把数组元素都设置为0.注解:对于动态分配的数组,其元素只能初始化为元素类型的默认值,而不能像数组变量一样,用初始化列表为数组元素提供各不相同的初值.3.const对象的动态数组如果我们在自由存储区中创建的数组存储了内置类型的const对象,则必须为这个数组提供初始化:因为数组元素都是const对象,无法赋值.实现这个要求的唯一方法是对数组做值的初始化://error:uninitialized const arrayconst int *pci_bad=new const int[100];//ok:value-initialized const arrayconst int *pci_ok=new const int[100]();C++允许定义类类型的const数组,但该类类型必须提供默认构造函数://ok:array of 100 empty stringsconst string *pcs=new const string[100];在这里,将使用string类的默认构造函数初始化数组元素.当然,已创建的常量元素不允许修改------因此这样的数组实际上用处不大.4.允许动态分配空数组之所以要动态分配数组,往往是由于编译时并不知道数组的长度.我们可以编写如下代码size_t n=get_size(); //get_size returns number of elements needed int *p=new int[n];for(int *q=p;q!=p+n;++q)/* process the array */;计算数组长度,然后创建和处理该数组.有趣的是,如果get_size返回0会怎么样?答案是:代码仍然正确执行.C++虽然不允许定义长度为0的数组变量,但明确指出,调用new动态创建长度为0的数组是合法的:char arr[0]; //error:cannot define zero-length arraychar *cp=new char[0]; //ok:but cp can't be dereferenced用new动态创建长度为0的数组时,new返回有效的非零指针.该指针与new返回的其他指针不同,不能进行解引用操作,因为它毕竟没有指向任何元素.而允许的操作包括:比较运算,因此该指针能在循环中使用;在该指针上加(减)0,或者减去本身值,得0值.在上述例题中,如果get_size返回0,则仍然可以成功调用new,但是p并没有指向任何对象,数组是空的.因为n为0,所以for循环实际比较的是p和q,而q是用p初始化的,两者具有相等的值,因此for循环条件不成立,循环体一次都没有执行5.动态空间的释放动态分配的内存最后必须进行释放,否则,内存最终将会逐渐耗尽.如果不再需要使用动态创建的数组,程序员必须显式地将其占用的存储空间返还给程序的自由存储区.C++语言为指针提供delete[]表达式释放指针所指向的数组空间:delete[] pia;该语句回收了pia所指向的数组,把相应的内存返还给自由存储区.在关键字delete和指针之间的空方括号对是必不可少的:它告诉编译器该指针指向的是自由存储区中的数组,而并非单个对象.小心:如果遗漏了空方括号对,这是一个编译器无法发现的错误,将导致程序在运行时出错.理论上,回收数组时缺少空方括号对,至少会导致运行时少释放了内存空间,从而产生内存泄漏(memory leak).对于某些系统和/或元素类型,有可能会带来更严重的运行时错误.因此,在释放动态数组时千万别忘了方括号对.C风格字符串与C++的标准库类型string的比较:以下两段程序反映了使用C风格字符串与C++的标准库类型string的不同之处.使用string类型的版本更短、更容易理解,而且出错的可能性更小://C-style character string implementationconst char *pc="a very long literal string";const size_t len=strlen(pc +1); //space to allocate//performance test on string allocation and copyfor(size_t ix=0;ix!=1000000;++ix){char *pc2=new char[len+1]; //allocate the spacestrcpy(pc2,pc); //do the copyif(strcmp(pc2,pc)) //use the nuw string; //do nothingdelete[] pc2; //free the memory}//string implementationstring str("a very long literal string");//performance test on string allocation and copyfor(int ix=0;ix!=1000000;++ix){string str2=str; //do the copy,automatically allocatedif(str!=str2) //use the new string; //do nothing} //str2 is automatically freed6.动态数组的使用通常是因为在编译时无法知道数组的维数,所以才需要动态创建该数组.例如,在程序执行过程中,常常使用char*指针指向多个C风格字符串,于是必须根据每个字符串的长度实时地动态分配存储空间.采用这种技术要比建立固定大小的数组安全.如果程序员能够准确计算出运行时需要的数组长度,就不必再担心因数组变量具有固定的长度而造成的溢出问题.假设有以下C风格字符串:const char *noerr="success";//...const char *err189="Error: a function declaration must ""specify a function return type!";我们想在运行时把这两个字符串中的一个复制给新的字符数组,于是可以用以下程序在运行时计算维数:const char *errorTxt;if(errorFound)errorTxt=err189;elseerrorTxt=noerr;//remember the 1 for the terminating nullint dimension=strlen(errorTxt)+1;char *errMsg=new char[dimension];//copy the text for the error into errMsgstrncpy (errMsg,errorTxt,dimension);别忘记标准库函数strlen返回的是字符串的长度,并不包括字符串结束符,在获得的字符串长度上必须加1以便在动态分配时预留结束符的存储空间.。
VC中动态创建二维数组的方法
VC中动态创建二维数组的方法VC中动态创建二维数组的方法先给了例子吧：如要想创建一个[m][n]的二维数组。
下面为通过动态创建一个指针数组的方法来动态创建二维数组的方法。
 double **data;data = new double*[m]; //设置行或直接double**data=new double*[m]; 一个指针指向一个指针数组。
for(int j=0;j<m;j++){data[j] = new double[n]; //这个指针数组的每个指针元素又指向一个数组。
}for (int i=0;i<m;i++)for (int j=0;j<n;j++){data[i][j]=i*n+j;//初始化数组元素}for (int i=0;i<m;i++){delete[] data[i]; //先撤销指针元素所指向的数组}delete[] data; （别人的一个例子，我改得更易读点）。
 这种方法是通过先动态创建一个指针数组，然后为指针数组的每个元素再动态指向一个数组的办法来完成的。
其创建过程与销毁过程两样重要。
在销毁的过程，先销毁指针数组每个元素指向的数组，然后再销毁这个指针数组。
应该也许会有很多办法来完成。
这只是一种方法，这也只是在自己用到时候套用别人的方法来写的，不过直到现在才理解是如何创建的。
知识只有在用的过程中才会掌握更细，理解更透彻。
点滴。
坚持。
遗留问题：这种方法可以动态创建更高维的数组吗？。
《C语言中动态数组的创建及引用》
《C语⾔中动态数组的创建及引⽤》C语⾔中动态数组的创建及引⽤ 动态数组是相对于静态数组⽽⾔的，静态数组的长度是预定义好的，在整个程序中，⼀旦给定了数组⼤⼩后就⽆法改变，，⽽动态数组则不然，它可以根据程序需要重新指定数组的⼤⼩。
动态数组的内存空间是由堆动态分配的，通过执⾏代码为其分配储存空间，只有程序执⾏到分配语句时，才为其分配储存空间。
对于动态数组，其创建⽐静态数组更⿇烦⼀些，使⽤完必须由程序员⾃⼰释放，否则将引起内存泄漏，但是其使⽤⾮常灵活，能根据程序需要动态分配⼤⼩，因此相对于静态数组来说，使⽤动态数组的⾃由度更⼤。
对于动态数组的创建和引⽤我们尤其需要注意的便是它的创建原则。
动态数组的创建原则：从外层项⾥层创建，从⾥层向外层逐渐释放。
下⾯通过代码实例来看看：⼀：⼀维动态数组创建⼀维动态数组的⼀般格式： 类型说明符 * 数组名 = (类型说明符 * )malloc(数组长度 * sizeof(类型说明符));代码实例：1 #include<stdio.h>2 #include<stdlib.h>3int main(void)4 {5int n,i;6int *arr;7 printf("请输⼊所要创建的⼀维动态数组的长度:");8 scanf("%d",&n);9if((arr=(int *)malloc(n*sizeof(int)))==NULL)10 {11 printf("分配内存空间失败，程序退出！");12return0;13 }14for(i=0;i<n;i++) /*向申请成功的数组中赋值*/15 {16 arr[i]=i+1;17 printf("%d\t",arr[i]);18if(0==(i+1)%4)19 printf("\n"); /*⼀⾏打印四个元素*/20 }21 free(arr); /*切记！使⽤完后记得要释放所申请的空间*/22return0;23 }该代码的运⾏结果为：请输⼊所要创建的⼀维动态数组的长度:12123456789101112点评：程序先使⽤了malloc()函数向系统动态申请分配了sizeof(int)*n个字节的内存空间，然后将申请的内存空间视为⼀个⼀维数组进⾏操作，当然，⼀维数组的申请并没有体现动态数组的分配原则。
C语言创建动态数组创建_函数定义
C语⾔创建动态数组创建_函数定义//函数定义///初始化结构体/if (IsFull(pArr)||IsEmpoty(pArr)){printf("插⼊失败，数组有效个数为空或已满，程序结束\n");return false;}if (pos<1 || pos > pArr->count+1) //⼩于1或者⼤于数组有效元素个数时，插⼊失败{printf("插⼊失败，插⼊位置不正确，程序结束\n");return false;}for (int i = pArr->count; i >= pos-1; i--){pArr->pBase[i] = pArr->pBase[i - 1];}pArr->count++;pArr->pBase[pos - 1] = val;printf("%d插⼊成功\n", val);return true;}}///删除函数的的定义//*pArr接收需要被操作的struct Array类型的地址//pos表⽰要删除的位置，从1开始，*pVal保存删除的值bool DeleteArray(struct Array *pArr, int pos,int *pVal){if (IsEmpoty(pArr)){printf("删除失败，数组有效个数为空，程序结束\n");return false;}else if (pos<1 || pos > pArr->count + 1){printf("删除位置不正确，程序结束\n");return false;}else{*pVal = pArr->pBase[pos - 1]; //保存删除的值for (int i = pos; i < pArr->count; i++){pArr->pBase[i - 1] = pArr->pBase[i];}printf("%d删除成功\n", *pVal);pArr->count--;return true;}}///获得指定值位置⼩标索引//*pArr接收需要被操作的struct Array类型的地址,val表⽰需要查找的值//找到返回索引值，没找到返回-1int GetIndex(struct Array *pArr, int val){if (IsEmpoty(pArr)){printf("查找失败，数组为空\n");return -1;}int index = -1; //保存返回索引值for (int i = 0; i < pArr->count-1; i++){if (pArr->pBase[i] == val){index = i+1;return index;//printf("%d查找成功,索引值为：%d",val, *index); }}if (index == -1){return -1;}}///升排序函数定义//*pArr接收需要被操作的struct Array类型的地址void SortArray(struct Array *pArr) //排序{int temp; //交换两个值的中间变量for (int i = 0; i < pArr->count-1; i++) //控制⽐较回合{for (int j = 0; j < pArr->count-1-i; j++) //控制⽐较次数{if (pArr->pBase[j] > pArr->pBase[j + 1]) //⼤于时交换{temp = pArr->pBase[j];pArr->pBase[j] = pArr->pBase[j + 1];pArr->pBase[j + 1] = temp;}}}}///数组翻转//*pArr接收需要被操作的struct Array类型的地址void ReverseArray(struct Array *pArr){if (IsEmpoty(pArr))return;int temp;for (int i = 0; i < (pArr->count-1)/2; i++){temp = pArr->pBase[pArr->count - 1 - i];pArr->pBase[pArr->count - 1 - i] = pArr->pBase[i]; pArr->pBase[i] = temp;}return;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
如何在VC中创建动态数组
关键词：VC 动态数组
怎样给多维数组动态分配内存
//Allocate:
int **p = new int* [m];
for(int i = 0 ; i < m ; i++)
p[i] = new int[n];
//Use:
for(int i = 0 ; i < m; i++)
for(int j = 0 ; j < n ; j++)
p[i][j] = i * j;
//Free:
for(int i = 0 ; i < m ; i++)
delete[] p[i];
delete[] p;
1. 演示形为int[2][3]的二维动态数组
///////////////////////////////////////////////////////////////////
int n1, n2;
const int DIM1 = 2;
const int DIM2 = 3;
// 构造数组
int **ppi = new int*[DIM1];
for(n1 = 0; n1 < DIM1; n1++)
{
ppi[n1] = new int[DIM2];
}
// 填充数据
for(n1 = 0; n1 < DIM1; n1++)
{
for(n2 = 0; n2 < DIM2; n2++)
{
ppi[n1][n2] = n1 * 10 + n2;
}
}
// 输出
for(n1 = 0; n1 < DIM1; n1++)
{
for(n2 = 0; n2 < DIM2; n2++)
{
afxDump << "ppi[" << n1 << "][" << n2 << "] = " << ppi[n1][n2] << "\n";
}
}
// 释放数组
for(n1 = 0; n1 < DIM1; n1++)
{
delete [] ppi[n1];
}
delete [] ppi;
2. 三维动态数组（int[2][3][4]）
///////////////////////////////////////////////////////////////////
int n1, n2, n3;
const int DIM1 = 2;
const int DIM2 = 3;
const int DIM3 = 4;
// 构造数组
int ***ppi = new int**[DIM1];
for(n1 = 0; n1 < DIM1; n1++)
{
ppi[n1] = new int*[DIM2];
for(n2 = 0; n2 < DIM2; n2++)
{
ppi[n1][n2] = new int[DIM3];
}
}
// 填充数据
for(n1 = 0; n1 < DIM1; n1++)
{
for(n2 = 0; n2 < DIM2; n2++)
{
for(n3 = 0; n3 < DIM3; n3++)
{
ppi[n1][n2][n3] = n1 * 100 + n2 * 10 + n3;
}
}
}
// 输出
for(n1 = 0; n1 < DIM1; n1++)
{
for(n2 = 0; n2 < DIM2; n2++)
{
for(n3 = 0; n3 < DIM3; n3++)
{
afxDump << "ppi[" << n1 << "][" << n2 << "][" << n3 << "] = "<< ppi[n1][n2][n3] << "\n";
}
}
}
// 释放数组
for(n1 = 0; n1 < DIM1; n1++) {
for(n2 = 0; n2 < DIM2; n2++)
{
delete [] ppi[n1][n2];
}
delete [] ppi[n1];
}
delete [] ppi;。