C语言中动态分配二维数组
C语言中动态分配二维数组
在C中动态分配内存的，对于单个变量，字符串，一维数组等，都是很容易的。C中动态分配二维数组的方法，很少有C语言书中描述，我查找了有的C语言书中提到了一个方法：假定二维数组的维数为[M][N]
分配是可以这样：
int **ptr=new int*[M]; //////这是先动态分配一个包含有M个指针的数组，即指先分配一个针数组
///////////指针数组的首地址保存在ptr中
for(int i=0;i ptr[i]=new int[N]; ////////////为指针数组的每个元素赋一个地址， ////这个地址是指向一维数组的地址，也即是为针元数组的每个元素分配一个数组 一个源代码的例子为： int **pMatrix = new int*[row]； for(int i = 0; i < row; i++) { pMatrix[i] = new int[column]; for(int j = 0; j < column; j++) { pMatrix[i][j] = (i+j); ///////简单的初始化 } } 这样创建一个数组有个严重的问题，就是它的内存不连续，行与行之间的内存不连续，虽然可以用[i][j]下标访问，无法满足用指向二维数组元素型别的指针变量来访问整个数组的要求. 例如不能如下访问每个二维数组元素： int * p = NULL; for(p = pMatrix[0]; p < pMatrix[0]+column * row; p++) { int fff = *(pme); } 而这种访问方式对于真正的二维数组是完全可以的。出现这种原因就是因为行与行之间的内存不连续造成的。 所以，这中方式创建的动态二维数组，不是真正意义上的二维数组。 那么什么是真正的二维数组呢？C语言中的二维数组在内存组织形式是按行存储的连续的内存区域。所以，必须保证数组元素是按行存储的，而且也是最重要的是内存要连续。 所以，我写出了如下的一个方法： 假定二维数组的元素变量类型是MyType；可以是C语言接受的除void之外的任何类型，因为编译器不晓得void类型的大小；例如int，float，double等等类型； int row = 2; /////暂假定行数是2，这个可以在运行时刻决定； int column = 3;/////暂假定列数是2，这个可以在运行时刻决定； void **ptdhead = NULL; //////////在后面说明为什么要用void**类型 void **ptdBody = NULL;//////////在后面说明为什么要用void**类型 ptdhead = (void **)malloc(sizeof(void*)*row + sizeof(MyType)*row*column); if(!ptdhead) return FALSE; ptdBody = ptdhead + row ; for(int ncount = 0; ncount < row; ncount++) ptdhead[ncount] = ptdBody + ncount * column* sizeof(MyType)/sizeof(void*); MyType**ptdheadRealse; ptdheadRealse = (MyType**)ptdhead;///////////////////强制转换为自己程序需要的二维数组元素类型的指针 ptdhead = NULL; for(int i = 0; i < row; i++ ) { for(int j = 0; j< column; j++) { ptdheadRealse[i][j] = i+j; ////////进行简单的初始化； } } 这样的一种方法动态分配的二维数组，内存是连续的，是真正意义的C语言二维数组，满足所有二维数组访问的方法，而且内存利用效率高，程序性能好。 这样一种分配方法要理解的是一下一点概念： 体会，只要是指针都可以带[],不管使直接指针，还是间接指针,都可以用下标，只要使指针就可以了，这个很关键； 另外就是要明白void*的指针是不能够用于加减法的，因为系统不晓得一个void型的大小，但是void**指针却是可以进行加减法，进行指针偏移的,因为void*型大小使知道的， 所以，编译器使可以计算出偏移地址的。 由于void型，系统不晓得大小，所以，void *p = (void*)malloc(3); 编译器无法通过如void *q = p+3; 我们知道假设一个整型变量nCont在32位机器上是4个字节，q是指向nCont的指针变量，q的值，也就是nCont的地址是0x00032ec0,那么q+1的值为0x0x00032ec0+1*4,这是C语言中计算指针表达式值的方法。即q+1的值为q+1*sizeof(int); 从这里，我们可以理解为什么我们用void**作为动态分配内存函数返回的类型，因为，如果返回的是void*类型，我们无法计算地址的偏移量，即无法计算出数组首元素的地址，也就是数组的地址。当然，我们可以不用void**,可以用除了void*的任何C中内嵌的简单类型，不过如果考虑使用起来简单，方便，那么我觉得还是悬着用void**,或者char*;选择char*类型方便的是，char类型的大小是1,那么元素的个数，即等于地址的偏移量。 构建实例 一维 #include #include int main() { int n1,i; int *array; puts("输入一维长度："); scanf("%d",&n1); array=(int*)malloc(n1*sizeof(int));//第一维 for(i=0;i { array[i]=i+1; printf("%d\t",array[i]); } free(array);//释放第一维指针 return 0; } 二维 #include #include int main() { int n1,n2; int **array,i,j; puts("输入一维长度:"); scanf("%d",&n1); puts("输入二维长度:"); scanf("%d",&n2); array=(int**)malloc(n1*sizeof(int*)); //第一维 for(i=0;i { array[i]=(int*)malloc(n2* sizeof(int));//第二维 for(j=0;j { array[i][j]=i+j+1; printf("%d\t",array[i][j]); } puts(""); } for(i=0;i { free(array[i]);//释放第二维指针 } free(array);//释放第一维指针 return 0; } 三维 #include int main() { int n1,n2,n3; int ***array; int i,j,k; puts("输入一维长度:"); scanf("%d",&n1); puts("输入二维长度:"); scanf("%d",&n2); puts("输入三维长度:"); scanf("%d",&n3); array=(int***)malloc(n1*sizeof(int**));//第一维 for(i=0; i { array[i]=(int**)malloc(n2*sizeof(int*)); //第二维 for(j=0;j { array[i][j]=(int*)malloc(n3*sizeof(int)); //第三维 for(k=0;k { array[i][j][k]=i+j+k+1; printf("%d\t",array[i][j][k]); } puts(""); } puts(""); } for(i=0;i { for(j=0;j { free(array[i][j]);//释放第三维指针 } } for(i=0;i { free(array[i]);//释放第二维指针 } free(array);//释放第一维指针 return 0; } 四维 #include int main() { int n1,n2,n3,n4; int ****array; int i,j,k,m; puts("输入一维长度:"); scanf("%d",&n1); puts("输入二维长度:"); scanf("%d",&n2); puts("输入三维长度:"); scanf("%d",&n3); puts("输入四维长度:"); scanf("%d",&n4); array=(int****)malloc(n1*sizeof(int***));//第一维 for(i=0; i { array[i]=(int***)malloc(n2*sizeof(int**)); //第二维 for(j=0;j { array[i][j]=(int**)malloc(n3*sizeof(int*)); //第三维 for(k=0;k { array[i][j][k]=(int*)malloc(n4*sizeof(int));//第四维 for(m=0;m { array[i][j][k][m]=i+j+k+m+1; printf("%d\t",array[i][j][k][m]); } puts(""); } puts(""); } puts(""); } for(i=0;i { for(j=0;j { for(k=0;k free(array[i][j][k]);//释放第四维指针 } } for(i=0;i { for(j=0;j { free(array[i][j]);//释放第三维指针 } } for(i=0;i { free(array[i]);//释放第二维指针 } free(array);//释放第一维指针 return 0; } 以三维整型数组array[n1][n2][n3]为例。 先遵循从外层到里层，逐层申请的原则： 最外层指针是array,它是个三维指针，所指向的是array[],其为二维指针。 所以给array（三维指针）申请内存应： array=(int***)calloc(n1,sizeof(int**)); 次层指针是array[]，它是个二维指针，所指向的是array[][]，其为一维指针。 所以给array[]（二维指针）申请内存应： for(i=0;i { array[i]=(int**)calloc(n2,sizeof(int*)); } 最内层指针是array[][],它是个一维指针，所指向的是array[][][]，其是个整型常量。所以给array[][]（一维指针）申请内存应： for(i=0;i { for(j=0;j { array[i][j]=(int*)calloc(n3,sizeof(int)); } } array[][][]（整型常量） 当然，你可以把它们整合在一起为： int i,j,k; int n1,n2,n3; int ***array; scanf("%d%d%d",&n1,&n2,&n3); array=(int***)calloc(n1,sizeof(int**)); for(i=0;i { array[i]=(int**)calloc(n2,sizeof(int*)); for(j=0;j { array[i][j]=(int*)calloc(n3,sizeof(int)); for(k=0;k { array[i][j][k]=i+j+k+1; } } } 最后不要忘了释放这些内存，这要遵循释放的时候从里层往外层，逐层释放的原则。分析过程可参考上面的解答，这里不再赘述。只给出代码吧： for(i=0;i { for(j=0;j { free(array[i][j]);//释放第一维指针 } } for(i=0;i { free(array[i]);//释放第二维指针 } free(array);//释放第三维指针 二维数组的动态分配与释放 1. C语言动态分配二维数组 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char) * M*N); //注意M为数组的行，N为数组的列printf("%d\n", sizeof(a));//4，指针 printf("%d\n", sizeof(a[0]));//N*sizeof(char)，一维数组 free(a); (2)已知第一维 Code-2 char* a[M];//指针的数组 int i; for(i=0; i 二维数组 我们以前学过的数组叫一维数组（只有一行） 二维数组，有行有列 0 1 2 3 0 1 2 3 4 1 5 6 7 8 2 9 10 11 12 如何来定义二维数组 格式：类型标识符数组名[行的长度][列的长度]； Int a[3][4] 讨论一下究竟有多少元素？元素个数=行的长度*列的长度意义：定义了一个二维数组名为A含有12个元素，每个元素都是一个整形变量，他们是： a[0][1],a[0][2]…对于第一行而言，行的下标都是零。 规律：对于每一行而言，行的下标不会改变，列的下标改变。 给二维数组赋初值（实际上是给二维数组中的每个元素付出只）1）int a[3][4]={1,2,3,4, 5,6,7,8, 9,10,11,12} ; 必须要会认，最基本的，比如a[2][0],分组后是9 2)int a[3][4]={1,2,3,4},{5,6,7,8}{9,10,11,12}; 3)可以省略行，但不能省略列 A：iint a[][4]= {1,2,3,4, 5,6,7,8, 9,10,11,12} ; B:int a[][4] ={1,2,3,4},{5,6,7,8}{9,10,11,12}; 4) int a[3][4]={1,2,3,4, 5,6,7,8, 9,10,11} ;可以少赋值，自动填0 a[2][3]=0 5) int a[][4] ={1,3,4},{5,6,7,8}{9,10,11,12}; a[0][3]=0 注意： 1)二维数组的复制原则，是要优先满足前面的行，然后再来满足后面的行 2)二维数组行的长度用来表明共有多少行，列的个数用来表明每行的元素个数 二维数组的输出 1）有数组就要循环 我们肯定要输出三行，每行要输出四个数据 第i行第j个元素：for(i=0;i<3(行的长度);i++) {for(j=0;j<4（列的长度）;j++) {printf(“%d”,a[i][j]);}//如果内循环做完了，表示第i行 就输出完了 printf(“/n”);} C++定义动态数组 首先：为什么需要动态定义数组呢？ 这是因为，很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出 但是问题是，c++要求定义数组时，必须明确给定数组的大小，要不然编译通不过 如：int Array[5];正确 int i=5; int Array[i]; 错误因为在编译阶段，编译器并不知道i 的值是多少 那么，我们该如何解决定义长度未知的数组呢？ 答案是：new 动态定义数组 因为new 就是用来动态开辟空间的，所以当然可以用来开辟一个数组空间 这样，下面的语句： int size=50; int *p=new int[size]; 是正确的 但是二维动态数组能不能也这样定义呢 int size=50,Column=50; int (*p)[Column]=new int [size][Column] 这样的语句，编译器通不过，为什么呢？ 首先new int[size][Column] 就是动态生成时确定的，所以它没有错 那么就是int（*p）[Column]，这句有问题了，这句为什么不对呢，那是因为，这是一个定义语句，而定义语句先经过编译器进行编译，当编译器运行到此处时，发现Column 不是常数，因此不能通过编译。而之所以编译器认为Column 不是常数，是因为编译阶段，编译器起的作用是查语法错误，和预分配空间，它并不执行程序，因此，没有执行那个赋值语句（只是对这个语句检查错误，和分配空间），因此编译阶段，它将认为column 是个变量。所以上面的二维数组定义是错误的，它不能通过编译。 改成这样： int size=50 int (*p)[50]=new int [size][50] 便正确了。 由此可见，这种动态分配数组，仅对一维数组空间是真正动态分配的。 但是如何真正的动态分配二维数组呢，即如果Column 也不能预先知道的话，该如何处理呢？ 上面的动态分配已经不能满足我们的要求，因为上面动态分配只对一维数组是真正动态的，对二维 二维数组定义以及动态分配空间(转) 下面三种定义形式怎么理解？怎么动态分配空间？ (1)、int **Ptr; (2)、int *Ptr[ 5 ]; 我更喜欢写成int* Prt[5]; (3)、int ( *Ptr )[ 5 ]; 此文引自网上，出处不详，但是觉得非常好。略改了一点。 多维数组一向很难，一般都采用一维数组，但是一旦要用到还真是头疼。 闲话少说，这里我就以三个二维数组的比较来展开讨论： (1)、int **Ptr; (2)、int *Ptr[ 5 ]; 我更喜欢写成int* Prt[5]; (3)、int ( *Ptr )[ 5 ]; 以上三例都是整数的二维数组，都可以用形如Ptr[ 1 ][ 1 ] 的 方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们 进行讨论： 一、内容： 它们本身都是指针，它们的最终内容都是整数。注意我这里说 的是最终内容，而不是中间内容，比如你写Ptr[ 0 ]，对于三者来说， 其内容都是一个整数指针，即int *；Ptr[ 1 ][ 1 ] 这样的形式才 是其最终内容。 二、意义： (1)、int **Ptr 表示指向"一群"指向整数的指针的指针。 (2)、int *Ptr[ 5 ] 表示指向5 个指向整数的指针的指针,或者说Ptr有5个指向"一群"整数的指针，Ptr是这5个指针构成的数组的地址 (3)、int ( *Ptr )[ 5 ] 表示指向"一群"指向5 个整数数组的指针的指针。 三、所占空间： (1)、int **Ptr 和(3)、int ( *Ptr )[ 5 ] 一样，在32位平台里，都是4字节，即一个指针。 但(2)、int *Ptr[ 5 ] 不同，它是5 个指针，它占5 * 4 = 20 个字节的内存空间。 四、用法： (1)、int **Ptr 因为是指针的指针，需要两次内存分配才能使用其最终内容。首 先，Ptr = ( int ** )new int *[ 5 ]；这样分配好了以后，它和(2)的 意义相同了；然后要分别对 5 个指针进行内存分配，例如： Ptr[ 0 ] = new int[ 20 ]; 它表示为第0 个指针分配20 个整数，分配好以后，Ptr[ 0 ] 为指 向20 个整数的数组。这时可以使用下标用法Ptr[ 0 ][ 0 ] 到 Ptr[ 0 ][ 19 ] 了。 如果没有第一次内存分配，该Ptr 是个"野"指针，是不能使用 的，如果没有第二次内存分配，则Ptr[ 0 ] 等也是个"野"指针，也 是不能用的。当然，用它指向某个已经定义的地址则是允许的，那是另外 的用法（类似于"借鸡生蛋"的做法），这里不作讨论（下同）。 例子： 完成下列程序代码 1、将二维数组（5行5列）的右上半部分置零。即： #include for(j=0;j<5;j++) { scanf("%d",&a[i][j]); } } int sum=a[0][0],x,y; for(i=0;i<5;i++) { for(j=0;j<5;j++) { if(sum C语言中动态分配二维数组 在C中动态分配内存的，对于单个变量，字符串，一维数组等，都是很容易的。C中动态分配二维数组的方法，很少有C语言书中描述，我查找了有的C语言书中提到了一个方法：假定二维数组的维数为[M][N] 分配是可以这样： int **ptr=new int*[M]; //////这是先动态分配一个包含有M个指针的数组，即指先分配一个针数组 ///////////指针数组的首地址保存在ptr中 for(int i=0;i C语言知识点总结8【二维数组】 一、二维数组的定义 ●一个3行，4列的二维数组。其行号：0,1,2；其列号：0,1,2,3 ●最大下标的元素为a[2][3],没有a[3][4]这个元素 ●数组共有3行，每一行都是：4个元素的一维数组，每一行的数组名分别为：a[0],a[1],a[2] ●从整体看，任何一个二维数组都可以看成是一个一维数组，只不过其数组元素又是一个一维数 组。 ●二维数组定义同时若有初始化，可以省略行号不写：如int a[][3]={1,2,3,4,5,6};系统会按照数据 的个数，和规定的列数，来确定数据分几行？ ●二维数组定义同时若有初始化，可以省略行号不写，但列号不能省略：如int a[3][ ]={1,2,3,4,5}; 系统无法按照数据的个数，和规定的行数，来确定数据分几列。 二、二维数组的存储及地址关系 二维数组在计算机中的存储是按行连续存储。先保存第一行，在第一行末尾开始存第二行，依此类推。 这里，a是a[0]的地址，a[0]是数组元素a[0][0]的地址，则a是地址的地址，即二级地址 三、 二维数组的初始化 1、 分行赋值：int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}}； 2、 不分行赋值：全部数据写在一个大括号内：int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12}； 3、 部分元素赋值 4、如果对全部元素赋初值，则第一维的长度可以不指定，但必须指定第二维的长度。 int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; 等价：int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12}; 四、 二维数组的输出 五、 二维数组的输入 RACI 什么是RACI模型？释义 RACI是一个相对直观的模型，用以明确组织变革过程中的各个角色及其相关责任。我们知道，变革过程是不可能自发或者自动进行的，必须有人对其进行作用，促使进程发生变化。因而，就很有必要对谁做什么，以及促发什么样的变革进行定义和描述。 除了RACI以外，还有RASCI或RASIC都是用来描述变革过程中的角色、任务的。 RACI的具体含义英文缩写 · 谁负责（R = Responsible），即负责执行任务的角色，他/她具体负责操控项目、解决问题。 · 谁批准（A = Accountable），即对任务负全责的角色，只有经他/她同意或签署之后，项目才能得以进行。 · 谁支持（S = Supportive），即提供信息资源，辅助执行任务的人员。 · 咨询谁（C = Consulted），拥有完成项目所需的信息或能力的人员。 · 通知谁(I =Informed), 即拥有特权、应及时被通知结果的人员，却不必向他/她咨询、征求意见。 RACI模型通常利用RACI表来帮助讨论、交流各个角色及相关责任。（参见右图） RACI的步骤 1. 辨识整个流程、找出各项活动，将它们记录在RACI表的左侧。 2. 辨识流程、活动中的所有角色，将它们记录在RACI表的上方。 3. 完成RACI表的方格单元：辨识每一个流程、活动的角色（R、A、S、C、I）。 4. 每一个流程最好只有一个“R”角色，这是RACI的一般原则。当一个流程找不到“R”角色时，则出现缺口。当一个流程有多个“R”角色时，则出现交叠。 5. 解决交叠问题。每个流程只能有一个“R”角色，以便明确流程的具体拥有者和责任。如果不止一个“R”存在，那么就要对该流程进行再分解，然而再对“R”进行分配。 R A C I责任分配矩阵 IMB standardization office【IMB 5AB- IMBK 08- IMB 2C】 RACI 什么是RACI模型？释义 RACI是一个相对直观的模型，用以明确组织变革过程中的各个角色及其相关责任。我们知道，变革过程是不可能自发或者自动进行的，必须有人对其进行作用，促使进程发生变化。因而，就很有必要对谁做什么，以及促发什么样的变革进行定义和描述。 除了RACI以外，还有RASCI或RASIC都是用来描述变革过程中的角色、任务的。RACI的具体含义英文缩写 ·谁负责（R=Responsible），即负责执行任务的角色，他/她具体负责操控项目、解决问题。 ·谁批准（A=Accountable），即对任务负全责的角色，只有经他/她同意或签署之后，项目才能得以进行。 ·谁支持（S=Supportive），即提供信息资源，辅助执行任务的人员。 ·咨询谁（C=Consulted），拥有完成项目所需的信息或能力的人员。 ·通知谁(I=Informed),即拥有特权、应及时被通知结果的人员，却不必向他/她咨询、征求意见。 RACI模型通常利用RACI表来帮助讨论、交流各个角色及相关责任。（参见右图）RACI的步骤 1.辨识整个流程、找出各项活动，将它们记录在RACI表的左侧。 2.辨识流程、活动中的所有角色，将它们记录在RACI表的上方。 3.完成RACI表的方格单元：辨识每一个流程、活动的角色（R、A、S、C、I）。 4.每一个流程最好只有一个“R”角色，这是RACI的一般原则。当一个流程找不到“R”角色时，则出现缺口。当一个流程有多个“R”角色时，则出现交叠。 5.解决交叠问题。每个流程只能有一个“R”角色，以便明确流程的具体拥有者和责任。如果不止一个“R”存在，那么就要对该流程进行再分解，然而再对“R”进行分配。 6.解决缺口问题。如果某个流程找不到“R”角色，这时对流程或项目负全责的权威人士则应该在现有角色中（或者发现新人选）挑选、任命一人担任“R”。更新RASCI表，对各个角色及其相关责任进行阐述 淮阴工学院 算法设计技能训练 设计题目：矩阵操作（动态数组） 院别：计算机与软件工程学院 专业：计算机科学与技术 班级：XXXXXXXXXX 学生姓名:XXX 学号:XXXXXXXXXX 指导教师:XXX XXX 2017 年11 月 算法设计技能训练成绩 班级：计算机1161 学生姓名:XXX学号:1161301105 院别：计算机与软件工程学院 算法设计技能训练题目：矩阵操作（动态数组） 教师签字： 日期： 目录 1 引言 (1) 1.1课题描述 (1) 1.2课题意义 (1) 1.3设计思想 (1) 2 总体设计 (2) 2.1总体功能结构 (2) 2.2类的分析与设计 (2) 3 详细设计和实现 (3) 3.1构建m*n的全零矩阵 (3) 3.2构建n*n的方阵 (3) 3.3拷贝构造函数（深拷贝） (3) 3.4根据一维数组拷贝函数 (3) 3.5根据二维数组拷贝函数 (3) 3.6析构函数 (4) 3.7矩阵转置 (4) 3.8矩阵信息获取及修改 (4) 3.9矩阵加法 (4) 3.10矩阵减法 (4) 3.11矩阵乘法 (5) 3.12重载=运算符 (5) 3.13打印函数 (5) 4 系统测试 (6) 4.1主界面 (6) 4.2创建矩阵 (6) 4.3矩阵相加 (8) 4.4矩阵相减 (9) 4.5矩阵数乘 (9) 4.6矩阵转置 (10) 4.6矩阵相乘 (10) 结论 (11) 致谢 (12) 参考文献 (13) 附录 (14) 1 引言 1.1课题描述 设计矩阵操作类算法，并做到可以动态的操作不同类型的数组，矩阵操作包括各种类型的构造函数如直接构造m*n型的全零矩阵或者全零方阵或者根据一维数组二维数组来构造矩阵，然后是析构函数。还需要返回行数列数以及设置某一位置的值和返回某一位置的值，操作类主要包括矩阵的转置、加减乘除和数乘赋值功能还有打印功能 1.2课题意义 矩阵是线性代数研究的主要对象。矩阵是由来源于某一问题的有关的数据所组成的矩形数表，在对矩阵定义了一些重要的运算并逐渐形成了矩阵的理论体系后，矩阵成为对数学研究即应用非常有效的数学工具，矩阵计算的理论与方法在许多实际问题研究中有着广泛的应用。将矩阵用代码实现可以大大减少实际计算工作量，使人们在生活研究方面得到很大的便利，省时省力。 1.3设计思想 本算法主要设计一个Matrix的类来实现矩阵的各种操作。该矩阵操作的数据类型可以自己选择，因为采用了模板，相对的设计时也会稍微繁琐一些。矩阵数据成员主要有矩阵元素的头指针，矩阵行数rowNum，矩阵列数colNum。公有成员函数则要实现各种方式的构造函数如直接构造m*n型的全零矩阵或者全零方阵或者根据一维数组二维数组来构造矩阵。获得矩阵信息的功能如获得矩阵的行数列数获得矩阵某一位置的值打印矩阵等。还有修改矩阵某一位置的值的功能，再接下来是最重要的矩阵的各种操作包括加减乘和数乘还有转置等，这些主要通过重载运算符来实现。 矩阵问题1.给一个二维数组A赋值如下数据： 2.输出以下5×5的矩阵 3.拐角矩阵 1)左上拐角 #include 2) 右下拐角 void main() { int i,j,k,n; printf("n : "); scanf("%d",&n); for(i=1;i<=n;i++) { for(j=1;j<=n;j++) { if(i<=j) printf("%4d",n+1-j); else printf("%4d",n+1-i); } printf("\n"); } } 3) 左下拐角 1 2 3 1 2 2 1 1 #include 可以用二维数组名作为实参或者形参，在被调用函数中对形参数组定义时可以指定所有维数的大小，也可以省略第一维的大小说明，如： void Func(int array[3][10]); void Func(int array[][10]); 二者都是合法而且等价，但是不能把第二维或者更高维的大小省略，如下面的定义是不合法的： void Func(int array[][]); 因为从实参传递来的是数组的起始地址，在内存中按数组排列规则存放(按行存放)，而并不区分行和列，如果在形参中不说明列数，则系统无法决定应为多少行多少列，不能只指定一维而不指定第二维，下面写法是错误的： void Func(int array[3][]);实参数组维数可以大于形参数组，例如实参数组定义为： void Func(int array[3][10]); 而形参数组定义为： int array[5][10]; 这时形参数组只取实参数组的一部分，其余部分不起作用。 对于数组int p[m][n]; 如果要取p[i][j]的值(i>=0 && i 二维数组传参||传值 先给出问题： 像下面这样的数组，在函数中如何传参？也就是说如何保证虚参与实参类型一致。 char str_arr[3][10] = {"yes","no","uncertain"}; char *str_array[] = {"yes","no","unsure"}; 函数原型： void func1( char (*a)[10] ) void func2( char **a ) 调用： func1( str_arr ); func2( str_array); 如果向func2()中传入str_arr会怎么样呢？编译器会警告：传递参数 1 (属于‘func2’)时在不兼容的指针类型间转换。即虚参与实参类型不一致。 同理，也不能向func1()中传入str_array。 我们给出完整的测试程序： /********二维数组传参测试程序***************/ #include 算法分析与设计课程论文 —通过C语言实现矩阵的相关操作 一．摘要 本文在Microsoft Visual Studio 2010的编译环境下，通过C语言进行一些矩阵的基本操作，包括矩阵的设置，加减乘除，数乘运算。求矩阵的逆等操作。 关键词 矩阵 C语言逆矩阵 二．正文 1.引言 矩阵的相关知识只是是高等数学的基础，但是其庞大的运算量和纷繁的步骤让人却步。虽然有Matlab等软件可以实现矩阵的相关操作，但是我校一些专业并不学习数学实验，故通过C语言实现矩阵的操作也是一种可行的方法，本文列举的了一些矩阵的加减乘除等基本运算规则，还有对矩阵进行转置，也有矩阵求逆的相关操作。 同时，还介绍了行列式的计算，通过运行该程序，可以大大简化行列式的计算量。 2.算法分析 矩阵的初始化 相关概念 在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，最早来自于方程组的系数及常数所构成的方阵。这一概念由19世纪英国数学家凯利首先提出。 矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。在物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。 理论分析 在C语言中，可以使用二维数组来描绘一个矩阵。值得注意的是，在二维数组中，必须标明列数，否则编译器就会报错。故二维极其多维数组使用时要注意数组下标。 代码实现 #include 摘要的重要性是不言而喻的，每次发文章我都很纠结如何写出一个有特色的摘要来，能够以最为简短的文字向读者描述出我所要表达的东西。但是常常出现的问题是，摘要写得太简短了，读者看了不清楚文章究竟要讲啥；摘要写得稍微长点的话自然能够描述清楚所要表达的东西，但是却也出现了另外一个问题，就是读者看到大段的文字描述，觉得枯燥无味，直接二话不说给文章判了个“死刑”，导致这种情况下愿意真正的花时间看完摘要的读者屈指可数，更不用说文章的正文部分了，所以时长感慨写文章最头疼的莫过于摘要了。 很多人在编写C语言代码的时候很少使用动态数组，不管什么情况下通通使用静态数组的 方法来解决，在当初学习C语言的时候我就是一个典型的例子，但是现在发现这是一个相 当不好的习惯，甚至可能导致编写的程序出现一些致命的错误。尤其对于搞嵌入式的人来所，嵌入式系统的内存是宝贵的，内存是否高效率的使用往往意味着嵌入式设备是否高质量和高性能，所以高效的使用内存对我们来说是很重要的。那么我们在自己编写C语言代码的时 候就应该学会使用动态数组，这也就是我这篇博客要给大家讲的，我尽我所能的用一些简单的代码来讲解动态数组，希望我所讲的对你有所帮助。 那么我们首先来看看什么是动态数组，动态数组是相对于静态数组而言，从“动”字我们也可以看出它的灵活性，静态数组的长度是预先定义好的，在整个程序中，一旦给定大小后就无法改变。而动态数组则不然，它可以随程序需要而重新指定大小。动态数组的内存空间是从堆动态分配的。是通过执行代码而为其分配存储空间。当程序执行到我们编写的分配语句时，才为其分配。对于静态数组，其创建非常方便，使用完也无需释放，要引用也简单，但是创建后无法改变其大小是其致命弱点！对于动态数组，其创建麻烦，使用完必须由程序员自己释放，否则将会引起内存泄露。但其使用非常灵活，能根据程序需要动态分配大小。所以相对于静态数组的来说我们对于使用动态数组有很大的自由度。 在创建动态数组的过程中我们要遵循一个原则，那就是在创建的时候从外层往里层，逐层创建；而释放的时候从里层往外层，逐层释放。这个话你读了可能理解并不深刻，不过不要急，接下来我们看看两段代码。 一维动态数组的创建： #include 前几日用C编写DSP程序时，遇到一个问题：如何向C函数中传递指向二维数组的指针参数。初接触以为很简单，直接声明一个二维数组，然后把数组名传进去。但是一经编译便报错。后来仔细想了一下，并查找了一些相关资料，发现二维数组在概念上远比一维数组复杂，或者说二维数组以一种晦涩的方式构建在一维数组之上。 先来回顾一下一维数组。一维数组的数组名即为指向该数组的指针，该指针值保存了数组存放在内存中的一块连续区域的起始地址；数组的下标表示了这片内存区域的某存储区相对于起始地址的偏移量。简单来讲就是：指向一维数组的指针，指向数据存放区域的起始位置。 事实上，计算机系统的多维数组其实最终还是以一维数组的形式实现的。就N x M的二维数组来讲，设其数组名为array。指针array 指向一个数组，该数组存放的是一系列指针，这些指针分别指向相应的一维数组，而这些数组中存放的才是我们的数据。 array -> [一维数组指针1] -> [ 一维数组，M长] [一维数组指针2] -> [ 一维数组，M长] …… …… [一维数组指针N] -> [ 一维数组，M长] 由此array是第i个指针变量地址，array[j]则表示相对于第i个指针变量偏移j*sizeof(数组类型)。系统通过这种机制访问了该二维数组的第i行，第j列的内容。 有上述可知，指向二维数组的指针其实是指向“指针变量地址”的指针变量。所以在声明指向二维数组的指针时，用int ** array的形式。 有以下两种方式来对二维数组分配内存： ///// 方法一 #include R A C I责任分配矩阵 SANY GROUP system office room 【SANYUA16H- RACI 什么是RACI模型？释义 RACI是一个相对直观的模型，用以明确组织变革过程中的各个角色及其相关责任。我们知道，变革过程是不可能自发或者自动进行的，必须有人对其进行作用，促使进程发生变化。因而，就很有必要对谁做什么，以及促发什么样的变革进行定义和描述。 除了RACI以外，还有RASCI或RASIC都是用来描述变革过程中的角色、任务的。 RACI的具体含义英文缩写 ·谁负责（R=Responsible），即负责执行任务的角色，他/她具体负责操控项目、解决问题。 ·谁批准（A=Accountable），即对任务负全责的角色，只有经他/她同意或签署之后，项目才能得以进行。 ·谁支持（S=Supportive），即提供信息资源，辅助执行任务的人员。 ·咨询谁（C=Consulted），拥有完成项目所需的信息或能力的人员。 ·通知谁(I=Informed),即拥有特权、应及时被通知结果的人员，却不必向他/她咨询、征求意见。 RACI模型通常利用RACI表来帮助讨论、交流各个角色及相关责任。（参见右图） RACI的步骤 1.辨识整个流程、找出各项活动，将它们记录在RACI表的左侧。 2.辨识流程、活动中的所有角色，将它们记录在RACI表的上方。 3.完成RACI表的方格单元：辨识每一个流程、活动的角色（R、A、S、 C、I）。 4.每一个流程最好只有一个“R”角色，这是RACI的一般原则。当一个流程找不到“R”角色时，则出现缺口。当一个流程有多个“R”角色时，则出现交叠。 5.解决交叠问题。每个流程只能有一个“R”角色，以便明确流程的具体拥有者和责任。如果不止一个“R”存在，那么就要对该流程进行再分解，然而再对“R”进行分配。 6.解决缺口问题。如果某个流程找不到“R”角色，这时对流程或项目负全责的权威人士则应该在现有角色中（或者发现新人选）挑选、任命一人担任“R”。更新RASCI表，对各个角色及其相关责任进行阐述 本文作者：黄邦勇帅 本文是学习C++的基础内容，指针是C或C++所特有的，因此应熟练掌握指针的使用，本文集中介绍C或C++中的各种指针，包括指针数组，数组指针，常量(const)指针，指向指针的指针，尤其是对二维数组和指针进行了详细精辟的解释，在读完本文的二维数组和指针的讲解之后，相信你就会对指针有一个车底的了解了。 本文内容完全属于个人见解与参考文现的作者无关，其中难免有误解之处，望指出更正。 声明：禁止抄袭本文，若需要转载本文请注明转载的网址，或者注明转载自“黄邦勇帅”。 主要参考文献： 1、C++.Primer.Plus.第五版.中文版[美]Stephen Prata著孙建春韦强译人民邮电出版社2005年5月 2、C++.Primer.Plus.第四版.中文版Stanley B.Lippman、Barbara E.Moo著李师贤等译人民邮电出版社2006年3月 3、C++.Primer.Plus.第三版.中文版Stanley B.Lippman等著潘爱民张丽译中国电力出版社2002年5月 4、C++入门经典第三版[美]Ivor Horton著李予敏译清华大学出版社2006年1月 5、C++参考大全第四版[美]Herbert Schidt著周志荣朱德芳于秀山等译电子工业出版社2003年9月 6、21天学通第四版C++ [美]Jesse Liberty著康博创作室译人民邮电出版社2002年3月 第一部分：指针 11.1 基础 1．指针是一个变量，它存储着另一个变量或函数的地址，也就是说可以通过指针间接地引用变量。指针变量包含一个地址，而且可以存储任何数据类型的内存地址，但指针变量却被声明为特定的数据类型，一个指向整型数据类型的指针不能存储一个浮点型的变量地址。 2．指针声明的形式为，数据类型＊指针变量名；其中＊星号是指针运算符，例如int *x；声明x为int型指针．11.2 指针运算符＊和&地址运算符 1．&地址运算符是一元运算符，能反回它的操作数的内存地址．如y=&x；把变量x的地址输入到y中，它与x的值无关，比如x的值为1000，而x的地址为55则，y将接收到地址55． 2．＊指针运算符是一元运算符，它是＆运算符的相反形式，＊运算符能反回位于其操作数所指定的地址的变量的值．例如y = &x；z = *y；假设x的值为1000，地址为55，则第二条语句说明z的值为1000，*y把由y所指向的内存的地址的变量x的值赋给z。*运算符可理解为“在地址中”，则z=*y可描术为“z接收了在址址y中的值。”，3．其实可以把*y当成一个变量来使用，即可以为*y赋值等，例如*y=100；(*y)++；等，但要注意的是对*y的操作相当于是对此指针指向的地址中的变量的操作，即对*y=100的赋值语句，相当于是x=100，而(*y)++则相当于x++。11.3 指针的运算 0．指针只支持4种算术运算符：++，――，＋，－．指针只能与整数加减．指针运算的原则是：每当指针的值增加时，它将指向其基本类型的下一个元素的存储单元．减少时则指向上一个元素的存储单元． 1．++，――运算符，假设int型x的地址为200，且int型占4个字节，定义int *p；p=&x；则p++的地址将是204，而不是201，因为当指针p的值增加时，它都将指向下一个int型数据．减少时也是这样，如p――则，p的地址将是196．2．+，－，运算符，注意两个指针不能相加．例int *p；p=&x；假设x的地址为200，则p+9将的指针地址将是200+4*9=236，即p指向了从当前正指向的元素向下的第9个元素． 3．两指针相减，同类型的一个指针减去另一个指针的值将是两个指针分开的基本类型的元素的个数． 11.4 指针和数组 1．在C++语言中使用没有下标的数组名会产生一个指向数组中第一个元素的指针．如char x[20]；char *p；p=x；此语句说明将x数组的第一个元素的地址赋给指针p． 2．*(p+4)和x[4]两句都可以访问数组中第5个元素，这里假设int x[33]；int *p；p=x；因为p是指向数组x的第一个元素地址的指针，而p+4就是指向第五个元素的指针，而*(p+4)就是第五的个元素了． 3．p[i]语句相当于*(p+i)或x[i]即数组中第i+1个元素的值，假设char x[20]；char *p；p=x； 11.5 字符串常量 在C中动态分配内存的，对于单个变量，字符串，一维数组等，都是很容易的。C中动态分配二维数组的方法，很少有C语言书中描述，我查找了有的C语言书中提到了一个方法： 假定二维数组的维数为[M][N] 分配是可以这样： int **ptr=new int*[M]; //////这是先动态分配一个包含有M个指针的数组，即指先分配一个针数组 ///////////指针数组的首地址保存在ptr中 for(int i=0;i { pMatrix[i] = new int[column]; for(int j = 0; j < column; j++) { pMatrix[i][j] = (i+j); ///////简单的初始化 } } 这样创建一个数组有个严重的问题，就是它的内存不连续，行与行之间的内存不连续，虽然可以用[i][j]下标访问，无法满足用指向二维数组元素型别的指针变量来访问整个数组的要求. 例如不能如下访问每个二维数组元素： int * p = NULL; for(p = pMatrix[0]; p < pMatrix[0]+column * row; p++) { int fff = *(pme); } 而这种访问方式对于真正的二维数组是完全可以的。出现这种原因就是因为行与行之间的内存不连续造成的。 所以，这中方式创建的动态二维数组，不是真正意义上的二维数组。 那么什么是真正的二维数组呢？C语言中的二维数组在内存组织形式是按行存储的连续的内存区域。所以，必须保证数组元素是按行存储的，而且也是最重要的是内存要连续。 所以，我写出了如下的一个方法： 假定二维数组的元素变量类型是MyType；可以是C语言接受的除void之外的任何类型，因为编译器不晓得void类型的大小；例如int，float，double等等类型； int row = 2; /////暂假定行数是2，这个可以在运行时刻决定； int column = 3;/////暂假定列数是2，这个可以在运行时刻决定； void **ptdhead = NULL; //////////在后面说明为什么要用void**类型二维数组的动态分配与释放
C语言笔记(二维数组-函数)
C++定义动态数组
二维数组定义以及动态分配空间(精)
c语言二维数组课堂编程练习
C语言中动态分配二维数组
C语言知识点总结8【二维数组】
RACI责任分配矩阵
RACI责任分配矩阵
矩阵操作C++
矩阵问题(c语言)讲解
C语言二维数组作为函数的参数
二维数组传参传值
c语言实现矩阵的相关操作
动态数组的创建
如何在C函数中传递指向二维数组的指针参数
RACI责任分配矩阵
C++指针与动态分配内存new关键字专题
C语言中动态分配二维数组