精华内容
下载资源
问答
  •  实体中变量都有默认初始化值  实体不在被使用,会在不确定时间内被垃圾回收器回收 方法区,本地方法区,寄存器 数组操作常见问题  数组脚标越界异常(ArrayIndexOutOfBoundsException) int[] ...
  • C语言入门系列之6.一维和二维数组

    千次阅读 2020-04-27 10:18:31
    二维数组的定义格式为类型说明符 数组名[常量表达式][常量表达式];,可理解为元素是一维数组一维数组;引用形式是数组名[下标][下标],可以有多种方式进行初始化。利用二分法查找数据可以大大加快查询速率;内存...

    一、数组的概念

    有如下几组数据:

    • 学生的学习成绩
    • 银行的账单
    • 一行文字

    这些数据的特点是:

    • 具有相同的数据类型
    • 使用过程中需要保留原始数据 。

    C语言为这类数据,提供了一种构造数据类型——数组

    在程序设计中,为了处理方便,把具有相同类型的若干变量按有序的形式组织起来,这些按序排列的同类数据元素的集合称为数组
    在C语言中,数组属于构造数据类型
    数组元素有序不是指元素大小顺序,而是位置顺序

    简而言之,数组就是具有相同类型的数据组成的序列,是一个有序集合。
    数组中的每一个数据称为数组元素,也称为下标变量,即每个元素由其所在的位置序号(即数组元素的下标)来区分。
    用数组名与下标可以用统一的方式来处理数组中的所有元素,从而方便地实现处理一批具有相同性质的数据的问题。

    一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型,因此按数组元素的类型不同,数组又可分为数值数组、字符数组、指针数组、结构数组等类别。

    二、一维数组的定义与引用

    1.一维数组定义

    在C语言中使用数组必须先进行定义。
    一维数组的定义方式为:

    类型说明符 数组名[常量表达式];
    

    例如int a[10]定义了一个整型数组,数组名为a,此数组有10个元素,10个元素都是整型变量。

    注意事项

    (1)类型说明符是任一种基本数据类型或构造数据类型,对于同一个数组,其所有元素的数据类型都是相同的。

    (2)数组名是用户定义的数组标识符,书写规则应符合标识符的书写规定。

    (3)方括号中的常量表达式表示数据元素的个数,也称为数组的长度。

    (4)允许在同一个类型说明中,说明多个数组和多个变量。
    例如int a, b, c, d, k1[10], k2[20];

    (5)a[10]表示a数组有10个元素,下标从0开始,这10个元素是a[0]、a[1]、…、a[9]。
    因此,不存在数组元素a[10]。

    (6)C语言不允许对数组的大小作动态定义,即数组的大小不依赖于程序运行过程中变量的值,因为在编译的时候就要为数组预留空间,所以在编写代码的时候不能通过变量来定义数组的大小。
    例如,下面这样定义数组是不行的:

    int n;
    scanf("%d"&n);  /* 在程序中临时输入数组的大小 */        
    int a[n];
    

    常见错误

    float a[0];     	/* 数组大小为0没有意义 */
    int b(2)(3);  		/* 不能使用圆括号 */
    int k, a[k];  		/* 不能用变量说明数组大小 */
    

    正确示意如下:

    int a[10];                  // 声明整型数组a,有10个元素。
    float b[10],c[20];          // 声明实型数组b,有10个元素,实型数组c,有20个元素。
    char ch[20];                // 声明字符数组ch,有20个元素。
    

    扩展:一维数组在内存中的存放

    定义一个一维数组int mark[100];,其在内存中地存放原理如下:
    一维数组在内存中的存放

    2.一维数组的引用

    数组元素是组成数组的基本单元,也是一种变量,其标识方法为数组名后跟一个下标,下标表示了元素在数组中的顺序号。
    引用数组元素的一般形式为数组名[下标],下标可以是整型常量或整型表达式
    例如:

    a[0] = a[5] + a[7] - a[2*3];
    a[i+j];
    a[i++];
    

    这些都是合法的数组元素引用。

    注意事项

    (1)数组元素通常也称为下标变量,必须先定义数组,才能使用下标变量。
    在C语言中只能逐个地使用下标变量,而不能一次引用整个数组。
    例如,输出有10个元素的数组必须使用循环语句逐个输出,示意如下:

    #include <stdio.h>
    
    int main(){
    	int i, a[10];
    	for(i = 0;i < 10; i++){
    		a[i] = i;
    	}
    	for(i = 9;i >= 0;i--){
    		printf("%d ", a[i]);
    	}
    	
    	return 0;
    } 
    

    打印:

    9 8 7 6 5 4 3 2 1 0
    

    不能用一个语句输出整个数组,printf("%d",a);写法是错误的。

    (2)定义数组时用到的数组名[常量表达式]和引用数组元素时用到的数组名[下标]是有区别的。
    例如∶

    int a[10];          	/* 定义数组长度为10 */
    t = a[6];             	/* 引用a数组中序号为6的元素,此时6不代表数组长度 */
    

    显然,两者的含义是不一样的。

    3.一维数组的初始化

    给数组赋值的方法除了用赋值语句对数组元素逐个赋值外,还可采用初始化赋值动态赋值的方法。
    数组初始化赋值是指在数组定义时给数组元素赋初值。
    数组初始化是在编译阶段进行的,这样将减少运行时间,提高效率;
    之前用赋值语句或输入语句也可给数组素指定初值,是在运行时完成。

    初始化赋值

    初始化赋值的一般形式为:

    类型说明符 数组名[常量表达式] = {,,,};
    

    具体的实现方法有以下几种:
    (1)在定义数组时对数组元素赋以初值。
    例如int a[10]= {0,1,2,3,4,5,6,7,8,9};,将数组元素的初值依次放在一对大括号内。
    经过上面的定义和初始化之后,得到a[0] = 0,a[1] = 1,…,a[9] = 9。

    测试如下:

    #include <stdio.h>
    
    int main(){
    	int i, a[10] = {0, 1, 2, 3, 4, 5, 6, 7 ,8 ,9};
    	for(i = 9;i >= 0;i--){
    		printf("%d ", a[i]);
    	}
    	
    	return 0;
    }
    

    与之前的效果是一样的。

    (2)可以只给一部分元素赋值。
    例如int a[10] = {0,1,2,3,4};定义a数组有10个元素,但大括号内只提供5个初值,这表示只给前面5个元素赋初值,后5个元素值为0。

    测试如下:

    #include <stdio.h>
    
    int main(){
    	int i, a[10] = {0, 1, 2, 3, 4};
        for(i = 9;i >= 0;i--){
            printf("%d ", a[i]);
        }
    	
    	return 0;
    }
    

    打印:

    0 0 0 0 0 4 3 2 1 0
    

    显然,未定义的元素默认为0。

    (3)如果想要使一个数组中全部元素值为0,可以写成int a[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};int a[10] = {0};

    (4)在对全部数组元素赋初值时,由于数据的个数已经确定,因此可以不指定数组长度。
    例如int a[5] = {1, 2, 3, 4, 5};也可以写成int a[] = {1, 2, 3, 4, 5};

    在第二种写法中,大括号中有5个数,系统就会据此自动定义a数组的长度为5。
    如果数组长度与提供初值的个数不相同,则数组长度不能省略。
    例如,想定义数组长度为10,就不能省略数组长度的定义,而必须写成int a[10] = {1, 2, 3, 4, 5}; 只初始化前5个元素,后5个元素为0。

    数组初始化与未初始化比较测试如下:

    #include <stdio.h>
    
    int main(){
    	int i, a[5] = {3, 4, 5}, b[5];
    	printf("Array a is:\n");
    	for(i = 0;i < 5;i++){
    		printf("%8d", a[i]);
    	}
    	printf("\nArray b is:\n");
    	for(i = 0;i < 5;i++){
    		printf("%8d", b[i]);
    	}
    	
    	return 0;
    }
    

    打印:

    Array a is:
           3       4       5       0       0
    Array b is:
          -1      -1 4236709       0       1
    

    显然,b数组未赋值,所以打印出了很乱、看不出规律的值。

    动态赋值

    动态赋值的方法示例如下:

    #include <stdio.h>
    
    int main(){
    	int i, max, a[10];
    	printf("Input 10 numbers:\n");
    	for(i = 0;i < 10;i++){
    		scanf("%d", &a[i]);
    	}
    	max = a[0];
    	for(i = 1;i < 10;i++){
    		if(a[i] > max){
    			max = a[i];
    		}
    	}
    	printf("max=%d", max);
    	
    	return 0;
    }
    

    打印:

    Input 10 numbers:
    13
    46
    70
    95
    73
    25
    62
    78
    54
    9
    max=95
    

    显然,在输入10个数给数组赋值后,打印出了最大值。

    练习:
    利用数组来求解Fibonacci数列前20个数。
    代码如下:

    #include <stdio.h>
    
    int main(){
    	int i;
    	int a[20] = {1, 1};
    	for(i = 2;i < 20;i++){
    		a[i] = a[i - 1] + a[i - 2];
    	}
    	
    	for(i = 0;i < 20;i++){
    		printf("%6d", a[i]);
    		if(i % 5 == 4){
    			printf("\n");
    		}
    	}
    	
    	return 0;
    }
    

    打印:

         1     1     2     3     5
         8    13    21    34    55
        89   144   233   377   610
       987  1597  2584  4181  6765
    

    练习:
    用冒泡法(起泡法)对10个数排序(由小到大)。
    代码如下:

    #include <stdio.h>
    
    int main(){
    	int i, j;
    	int a[10];
    	for(i = 0;i < 10;i++){
    		scanf("%d", &a[i]);
    	}
    	
    	for(i = 9;i >= 1;i--){
    		for(j = 0;j < i;j++){
    			int temp;
    			if(a[j] > a[j + 1]){
    				temp = a[j];
    				a[j] = a[j + 1];
    				a[j + 1] = temp;
    			}
    		}
    	}
    	printf("The sorted nubers:\n");
    	for(i = 0;i < 10;i++){
    		printf("%d ", a[i]);
    	}
    	
    	return 0;
    }
    

    打印:

    12 37 65 43 97 82 120 63 9 17
    The sorted nubers:
    9 12 17 37 43 63 65 82 97 120
    

    显然,最后得到的就是已经排好序的数组。

    三、二维数组的定义和引用

    1.二维数组的定义

    二维数组定义的一般形式为:

    类型说明符 数组名[常量表达式][常量表达式];
    

    例如:定义a为3X4 (3行4列)的数组,b为5X10(5行10列)的数组,如下:

    float a[3][4], b[5][10];
    

    不能写成

    float a[3, 4], b[5, 10];
    

    二维数组可理解为元素是一维数组的一维数组,例如int a[3][4];理解如下:
    二维数组理解
    多维数组的定义:
    例如float a[2][3][4];

    二维数组在内存中的存放方式示意如下:
    二维数组在内存中的存放

    三维数组在内存中的存放方式示意如下:
    三维数组在内存中的存放

    2.二维数组的引用和初始化

    引用数组元素的表示形式:

    数组名[下标][下标]
    

    其中,下标可以是整型常量或整型表达式

    int a[4][3], i=2, j=1;
    a[2][3];
    a[i][j];
    a[i+1][2*j-1];
    

    a[i, j]就是错误的。

    初始化数组的形式为:

    数据类型 数组名[常量表达式1][常量表达式2] = {初始化数据};
    

    有4种方法对二维数组初始化:
    (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)可以对部分元素赋初值。
    int a[3][4]={{1}, {5}, {9}};,存放如下:
    二维数组的初始化-方式三1
    int a[3][4] = {1, 5, 9}是给a数组的第一个子数组a[0]的前3个元素赋值,与前者不一样。

    也可以对各行中的某一或某些元素赋初值。
    int a[3][4]={{1}, {0, 6}, {0, 0, 11}};,存放如下:
    二维数组的初始化-方式三2

    还可以只对某几行元素赋初值。
    int a[4][4]={{1}, {5, 6}};,存放如下:
    二维数组的初始化-方式三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};

    在定义时也可以只对部分元素赋初值而省略第一维的长度,但应分行赋初值。
    int a[][4] ={{0, 0, 3}, {}, {0, 10}};,存放如下:
    二维数组的初始化-方式四

    练习:
    如下图,一个学习小组有5个人,每个人有三门课的考试成绩。将各个数据保存到二维数组a[5][3]中,并求全组分科的平均成绩和总平均成绩。
    二维数组的初始化-成绩例题

    代码如下:

    #include <stdio.h>
    
    int main(){
    	int i, j;
    	double savg[3];
    	int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}};
    	for(i = 0;i < 3;i++){
    		int sum = 0;
    		for(j = 0;j < 5;j++){
    			sum += a[j][i];
    		}
    		savg[i] = sum / 5.0;
    	}
    	int tavg = 0;
    	for(i=0;i<3;i++){
    		printf("Average Grade:%.2f\n", savg[i]);
    		tavg += savg[i];
    	}
    	printf("Total AVerage Grade is:%.2f", tavg / 3.0);
    	
    	return 0;
    }
    

    打印:

    Average Grade:72.20
    Average Grade:73.40
    Average Grade:81.60
    Total AVerage Grade is:75.33
    

    练习:
    将一个二维数组行和列元素互换,存到另一个二维数组中。
    例如,将数组a[2][3]转化为数组b[3][2]如下:
    二维数组的初始化-转置例题

    代码:

    #include <stdio.h>
    
    int main(){
    	int i, j;
    	int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}}, b[3][5];
    	printf("Array A:\n");
    	for(i = 0;i < 3;i++){
    		for(j = 0;j < 5;j++){
    			printf("%4d", a[j][i]);
    			b[i][j] = a[j][i];
    		}
    		printf("\n");
    	}
    	printf("Arary B:\n");
    	for(i = 0;i < 5;i++){
    		for(j = 0;j < 3;j++){
    			printf("%4d", b[j][i]);
    		}
    		printf("\n");
    	}
    	
    	return 0;
    }
    

    打印:

    Array A:
      80  61  59  85  76
      75  65  63  87  77
      92  71  70  90  85
    Arary B:
      80  75  92
      61  65  71
      59  63  70
      85  87  90
      76  77  85
    
    

    练习:
    有一个矩阵,要求编写程序求出其中最大的元素,以及其所在的行号和列号。
    代码如下:

    #include <stdio.h>
    
    int main(){
    	int i, j, row = 0, column = 0, max = 0;
    	int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}};
    	max = a[0][0];
    	for(i = 0;i < 3;i++){
    		for(j = 0;j < 5;j++){
    			if(a[j][i] > max){
    				max = a[j][i];
    				row = j;
    				column = i;
    			}
    		}
    	}
    	printf("Max=%d, in row %d column %d", max, row, column);
    	
    	return 0;
    }
    

    打印:

    Max=92, in row 0 column 2
    

    练习:
    从键盘上输入9个整数,(对照九宫格的形式,输入三行,每行输入三个数) 保存在二维数组中,按数组原来位置输出第一行和第一列的所有元素。
    如果数组如下:
    二维数组的初始化-九宫格例题输入

    则输出为:
    二维数组的初始化-九宫格例题输出

    代码如下:

    #include <stdio.h>
    
    int main(){
    	int i, j, a[3][3];
    	for(i = 0;i<3;i++){
    		for(j = 0;j<3;j++){
    			printf("a[%d][%d] = ", i, j);
    			scanf("%d", &a[i][j]);
    		}
    	}
    	for(i=0;i<3;i++){
    		for(j=0;j<3;j++){
    			if(i == 1 || j == 1){
    				printf("%-6d", a[i][j]);
    			}
    			else{
    				printf("%-6c", ' ');
    			}
    		}
    		printf("\n");
    	}
    	
    	return 0;
    }
    

    打印:

    a[0][0] = 12
    a[0][1] = 34
    a[0][2] = 56
    a[1][0] = 78
    a[1][1] = 90
    a[1][2] = 98
    a[2][0] = 76
    a[2][1] = 54
    a[2][2] = 43
          34
    78    90    98
          54
    
    

    四、数组的应用:二分法

    利用数组进行数据查找——二分法(也叫折半查找法):
    适应情况:
    在一批有序数据中查找某数;
    基本思想:
    选定这批数中居中间位置的一个数与所查数比较,看是否为所找之数,若不是,利用数据的有序性,可以决定所找的数是在选定数之前还是在之后,从而很快可以将查找范围缩小一半。以同样的方法在选定的区域中进行查找,每次都会将查找范围缩小一半,从而较快地找到目的数。

    练习:
    假设在数组a中的数据是按由小到大顺序排列的:
    -12 0 6 16 23 56 80 100 110 115
    从键盘上输入一个数,判定该数是否在数组中,若在,输出所在序号。
    实现思路:

    1. 设low、mid和high三个变量,分别指示数列中的起始元素、中间元素与最后一个元素位置,其初始值为low=0,high=9,mid=4,判断mid指示的数是否为所求,mid指示的数是23,不是要找的80,须继续进行查找。
    2. 确定新的查找区间。因为80大于23,所以查找范围可以缩小为23后面的数,新的查找区间为[56 80 100 110 115],low、mid、high分别指向新区间的开始、中间与最后一个数。实际上high不变,将low(low=mid+1)指向56,mid (mid=(low+high)/2)指向100,还不是要找的80,仍须继续查找。
    3. 上一步中,所找数80比mid指示的100小,可知新的查找区间为[56 80],low不变,mid与high的值作相应修改。mid指示的数为56,还要继续查找。
    4. 根据上一步的结果,80大于mid指示的数56,可确定新的查找区间为[80],此时,low与high都指向80,mid亦指向80,即找到了80,到此为止,查找过程完成。

    注意:
    若在查找过程中,出现low > high的情况,则说明序列中没有该数,亦结束查找过程。

    代码如下:

    #include <stdio.h>
    #define M 10
    
    int main(){
    	static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115};		// 定义静态变量 
    	int n, low = 0, mid, high = M - 1, found = 0;
    	printf("Input a number to be searched:\n");
    	scanf("%d", &n);
    	while(low <= high){
    		mid = (low + high) / 2;
    		if( n== a[mid]){
    			found = 1;
    			break;
    		}
    		else if(n > a[mid]){
    			low = mid + 1;
    		}
    		else{
    			high = mid - 1;
    		}
    	}
    	if(found == 1){
    		printf("The number %d is found, and the index is %d\n", n, mid);
    	}
    	else{
    		printf("The number %d is not found\n", n);
    	}
    	
    	return 0;
    }
    

    打印:

    Input a number to be searched:
    80
    The number 80 is found, and the index is 6
    
    

    可以看到,在程序中定义了一个静态变量;
    C程序在编译时,普通变量存放在栈区,static关键字会使变量存放在data区。

    补充知识——内存分为四大区:

    • code区
      写的代码存放的地方。
    • data区
      常量、字符串和static声明的变量存放的地方,特点是不会改变,整个程序结束之后才会释放。
    • stack区
      普通变量存放的地方,函数调用完成后就会释放。
    • heap区
      malloc函数定义,由开发者自己分配。

    还可以进一步优化:
    如果输入的数大于最大的数或小于最小的数,说明这个有序序列中不存在要寻找的数,可以直接不用循环查找,改进如下:

    #include <stdio.h>
    #define M 10
    
    int main(){
    	static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115};
    	int n, low = 0, mid, high = M - 1, found = 0;
    	printf("Input a number to be searched:\n");
    	scanf("%d", &n);
    	if(n < a[0] || n > a[M - 1]){
    		while(low <= high){
    			mid = (low + high) / 2;
    			if( n== a[mid]){
    				found = 1;
    				break;
    			}
    			else if(n > a[mid]){
    				low = mid + 1;
    			}
    			else{
    				high = mid - 1;
    			}
    		}
    		if(found == 1){
    			printf("The number %d is found, and the index is %d\n", n, mid);
    		}
    		else{
    			printf("The number %d is not found\n", n);
    		}
    	}
    	else{
    		printf("Illegal Input!!!");	
    	}
    	
    	return 0;
    }
    

    打印:

    Input a number to be searched:
    a
    Illegal Input!!!
    

    显然,此时可以识别非法输入。
    也可以改进如下:

    #include <stdio.h>
    #define M 10
    
    int main(){
    	static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115};
    	int n, low = 0, mid, high = M - 1, found = 0;
    	printf("Input a number to be searched:\n");
    	scanf("%d", &n);
    	while(scanf("%d", &n) != 1){
    		printf("Illegal Input!!\nPlease Input Again!!\n");
    		getchar();
    	}
    	while(low <= high){
    		mid = (low + high) / 2;
    		if( n== a[mid]){
    			found = 1;
    			break;
    		}
    		else if(n > a[mid]){
    			low = mid + 1;
    		}
    		else{
    			high = mid - 1;
    		}
    	}
    	if(found == 1){
    		printf("The number %d is found, and the index is %d\n", n, mid);
    	}
    	else{
    		printf("The number %d is not found\n", n);
    	}
    	
    	return 0;
    }
    

    打印:

    Input a number to be searched:
    a
    Illegal Input!!
    Please Input Again!!
    bc
    Illegal Input!!
    Please Input Again!!
    Illegal Input!!
    Please Input Again!!
    12
    The number 12 is not found
    
    

    显然,此时如果输入有误,会提示再输入,直到输入合法,再向下执行并判断。

    展开全文
  • 以下能对二维数组a进行正确初始化的语句是()。 正确答案: B 你的答案: D (错误) int a[2][ ]={{1,0,1},{5,2,3}}; int a[ ][3]={{1,2,3},{4,5,6}}; int a[2][4]={{1,2,3},{4,5},{6}}; int a[ ][3]={{1,0,1},{},{...

    以下能对二维数组a进行正确初始化的语句是()。
    正确答案: B 你的答案: D (错误)

    int a[2][ ]={{1,0,1},{5,2,3}};
    int a[ ][3]={{1,2,3},{4,5,6}};
    int a[2][4]={{1,2,3},{4,5},{6}};
    int a[ ][3]={{1,0,1},{},{1,1}};

    【解释】定义二维数组并赋初值时,可以省略第一维的大小,但不能省略第二维的大
    小,所以A是错误的;对于C来说,定义的数组a是2行4列的数组,但赋初值却包含了
    3行,所以是错误的;D中初值列表中有一行是空的,这在C语言中是不允许的,所以也
    是错误的;B定义了2行3列的二维数组并对其赋初值,是正确的,所以正确答案是B

    展开全文
  • 说白了就是*p是不能进行赋值操作,但要注意随着指针指向改变,*p也是会改变。 int a=10; int b=20; const int*p;//不必初始化 p=&a; cout<<"*p="<<*p<<endl;//输出结果*p=10 //*p=...

    一、const在指针中的应用(以int作为数据类型代表)
    1、常量指针(const int* p):指针的指向可以更改,但指针指向的值不可以直接更改。
    说白了最大的特点就是对 *p是不能进行赋值操作的,但要注意随着指针指向的改变,或者指向的变量本身的值的改变,*p也是会改变的。

    int a=10int b=20const int*p;//不必初始化
    p=&a;
    cout<<"*p="<<*p<<endl;//输出结果*p=10
    //*p=20为非法语句
    p=&b;//或者a=b
    cout<<"*p="<<*p<<endl;//输出结果*p=20
    

    2、指针常量(int* const p):指针的指向不可以更改,但指针的内容可以更改。
    说白了就是初始化后不能再让指针指向别的地址,但依旧可以通过改变指向的变量的值,或者直接对 *p赋值来改变该地址的内容。
    指针常量在定义时就应该被初始化,且初始化的地址必须是一个变量的地址,如果用常量的地址则会被报错。可能是因为能够通过 *p来重新赋值,这可能会与常量属性产生矛盾。

    int a=10;
    const int b=20;
    int* const p=&a;
    *p=b;//a=b;将*p的值改为20
    cout<<"a="<<a<<endl;//输出结果a=20
    

    3、指向常量的指针常量(const int* const p):不能更改指针的方向,不能通过*p更改指针指向的值。
    该类型指针在定义时也必须初始化,用来初始化的地址可以是常量地址,也可以是变量地址。当初始化使用的是常量地址时,指针指向的地址和该地址内的值都不可以再更改(这与上一个指针不能使用常量地址初始化似乎相关);当初始化使用的是一个变量地址时,就只能通过对变量赋值来改变地址中的值。

    const int a=10;
    const int* const p1=&a;//这样大家就都动不了了
    int b=10;
    const int* const p2=&b;
    b=20;//通过对变量赋值来改变地址中存放的值
    cout<<"*p="<<*p<<endl;//*p=20
    

    4、const 表示“只读”的含义的应用
    在使用传引用(即地址传递,pass by reference)时,如果在形参前加上const就不会对实参产生影响,同时又避免了重新分配内存空间,但相应的函数中就不能出现对形参赋值的语句。

    void plusone(int a){
    	a+=1;
    	cout<<&a<<endl;
    }
    int main(){
    	int a=0;
    	plusone(a);
    	cout<<"a="<<a<<endl;//输出结果a=0
    	cout<<&a<<endl;//输出的两个地址不相同
    }
    /*--------------------------------------*/
    void plusone(int&a){
    	a+=1;
    	cout<<&a<<endl;
    }
    int main(){
    	int a=0;
    	plusone(a);
    	cout<<"a="<<a<<endl;//输出结果a=1
    	cout<<&a<<endl;//输出的两个地址相同
    }
    /*---------------------------------------*/
    void plusone(const int&a){
    	//a+=1;报错,error:assignment of read-only reference'a'
    	cout<<&a<<endl;
    }
    int main(){
    	int a=0;
    	plusone(a);
    	cout<<&a<<endl;//输出的两个地址相同
    }
    

    二、类中含有指针类型的成员变量
    类中有指针类型的变量作为成员变量时(一般说来是没必要出现的,而且出现的情况以字符指针为主),需要对拷贝构造函数(自带的是浅拷贝,可能会导致一个内存被释放两次而出错),析构函数自行定义,并对等号进行重载。在所有函数中涉及关于指针变量的形参时,都应要加上const,强调“只读”。(同时强调一下在有人为定义的构造函数时系统就不会默认加上了一个空的无参构造函数,所以无论是重写还是在定义对象时赋初值一定要注意到。另外人为定义的带有默认参数的构造函数可以充当无参构造函数初始化没有括号的对象。)

    #include<iostream>
    #include<cstring>
    using namespace std;
    
    class sim{
    public:
    	sim(){
    	name=NULL;
    	num=0;
    	}
    	sim(const char*n,int a){
    	name=new char[strlen(n)+1];//在堆中给指针所指的对象分配一个连续的类似数组的空间(所以是方括号),strlen只能读出字符个数,要加1给'\0',而这个'\0'是不能被strlen读出的
    	strcpy(name,n);
    	num=a;
    	}
    	sim(const sim&s){//拷贝构造函数,对对象的成员变量初始化即可
    	name=new char[strlen(s.name)+1];//深拷贝
    	strcpy(name,s.name);
    	num=s.num;
    	}
    	sim operator=(const sim&s){//赋值号“=”的重载,与拷贝构造函数相比多了一个返回值类型和删除原成员变量
    	delete[]name;
    	name=new char[strlen(s.name)+1];
    	strcpy(name,s.name);
    	num=s.num;
    	return*this;
    	}
    	~sim(){//一般析构函数都是用来清理内存空间的,写了为空系统也会自动清理,但申请的堆空间不会被系统主动释放,为防止内存泄漏就必须写进构造函数中
    	delete[]name;
    	}
    	void getf(){
    	cout<<name<<":"<<num<<endl;
    private:
    	char*name;
    	int num;
    }
    int main(){
    	sim s1("Morty",14);
    	sim s2(s1);
    	sim s3("Jerry",34);
    	s2.getf();//输出:Morty:14
    	s2=s3;
    	s2.getf();//输出:Jerry:34
    

    三、字符指针和一维字符数组
    1、一维字符数组的定义方式:
    (!!!注意区分第二第三两种定义方式)

    char a[]="Jerry";//字符串可以是任意长度
    char a[10]="Jerry";//字符串长度必须小于10,最多9个字符,预留一个位置给'\0'
    char a[]={'J','e','r','r','y'};//可以在方括号中定义数组的大小(大于等于元素个数),也在大括号中加上'\0'(只会读取其前面的元素,表示读取的结束,并且占一个元素位置)
    cout<<*a<<endl;//输出J
    cout<<a<<endl;//输出Jerry
    

    在一维字符数组中数组名既表示首地址,又可以表示整个数组,相当于字符串的名字。所以 *a输出的结果为首地址存放的字符,a的输出结果为整个字符串(这是因为在C语言中没有字符串string类型,所以用字符数组来巧妙地代替,而普通数组直接输出数组名得到的结果一般都是地址)。
    2、字符指针和字符数组:
    鉴于一维数组的数组名本身具有地址含义,所以用指针指向时不用写&(取址符)。

    char*p=a;
    

    也可以直接对字符指针赋值,但一般要加上const,表示“只读”,因而不能对字符串进行修改。(如果没有加const,也不能说是错的,可以编译运行,但如果再通过 *p来改变字符,可以编译但是没有运行结果。)两种情况都是编译器的优化处理,确保字符串常量不会被修改。(这种直接对指针赋值所用的双引号内的内容是一个字符串常量,如同1、2和3等这些数字是整型常量一样。)

    const char*p="Jerry";
    

    3、读入字符串的不同方式:
    **输入原理简述:**程序的输入都建有一个缓冲区,即输入缓冲区。每次输入过程中会把键盘输入的数据存入缓冲区,而cin、getline、cin.get等都是再将缓冲区中的内容读入到变量中。
    **另:**读入的字符串不能直接给字符指针赋值(编译会通过但是没有运行结果),指针和字符串的关系是指向,字符串不能作为指针的内容。所以要使用空间申请char*p=new char[10],记得要delete[]p以防止内存泄露。
    (1)cin:

    char a[10];//或者char a[]={0};不确定元素个数就必须要进行初始化
    char b[]={0};
    cout<<"输入两段字符串:"<<endl;//提示作用,假设输入的内容为helllo world
    cin>>a;
    cout<<a<<endl;//输出hello
    cin>>b;
    cout<<b<<endl;//输出world
    

    cin的读入遇到空格、tab和回车都会结束,所以读入的只能是一串连续的字符。因为cin函数是直接从缓冲区取数据的,所以当缓冲区有残余数据时,cin函数会直接取这些残余的数据不会再请求键盘输入。对于这种情况也有专门的解决办法,那就是在cin>>b之前通过cin.sync()来清空缓冲区。
    (2)cin.get()
    (a)输入单个字符:

    char a=cin.get();
    char b;
    cin.get(b);
    //两种输入方式
    

    在和for循环搭配后就可以给字数数组赋值从而获得字符串了:

    char a[10];
    for(int i=0;i<10;i++){
    	a[i]=cin.get();
    }
    

    当然,定义的数组容量可能不会正好是所需字符串的长度(一般为了输入完整肯定是大于),所以多余的部分可以通过空格、tab和回车来填充。cin.get()此处读入的是单字符,空格、tab和回车作为“看不见的字符”也在读入范围内。
    (b)两种用法:
    cin.get(字符数组名,size):

    char a[5];
    char b[15];
    cin.get(a,10);//输入jkljkljkljkl
    cin.sync();//清空输入缓冲区
    cin.get(b,10);//输入jkljkljkljkljkl
    cout<<a<<endl;//输出jkljkljkl
    cout<<b<<endl;//输出jkljkljkl
    

    该函数会给字符数组读入(size-1)个字符,留一个位置给’\0’,同时,定义时的数组大小关系不大,以size为准,原来定义的数组长度不够会自动扩充,原来过长因为会自动加上’\0’所以也不会出问题。

    cin.get(数组名,size,结束字符)——会保留结束字符,取size和结束字符的“交集”:

    char a[10];
    cin.get(a,20,'s');//输入jkljklajkljkl
    cout<<a<<endl;//输出jkljkla
    

    (c)完整用法:cin.getline(字符数组名,size,结束字符)——不会保留结束字符,取size和结束字符的“交集”;
    省略用法:cin.getline(字符数组名,size):

    char a[10];
    char b[10];
    char c[10];
    cin.getline(a,5,'s');//输入jklsjkljkls
    cin.sync();
    cin.getline(b,25);//输入Make each day count.
    cin.sync();
    cin.getline(c,10);//输入jkljkljkljkl
    cout<<a<<endl;//输出jkl
    cout<<b<<endl;//输出Make each day count.
    cout<<c<<endl;//输出jkljkljkl,即(size-1)个字符
    

    (d)getline(cin,字符串名):
    注意:前面三种输入方式函数都属于iostream流,而getline()则不同,属于string的一个函数,所以在使用时要包含头文件#include<string>(具体还有很多用法,暂时不太懂)

    #include<string>
    
    string a;
    getline(cin,a);//输入:I am so happy!
    cout<<a<<endl;//输出:I am so happy!
    

    getline()在读入时没有字符限制,只会将转行(即回车和’\n’)视为结束的标志,不能给字符数组赋值,因为字符数组不是string类型,不能使用string类中的函数。
    三、字符指针和二维数组(以int为例)

    int a[3][4];
    int*p1;
    p1=*a;//令指针P1指向数组a的首地址,p+1指向的是a[0][1]的地址
    //也可以写成p1=a[0]
    int (*p2)[4];
    p2=a;//p2指向的也是a[0][0],但p+1指向的是a[1][0]
    //以下同行输出结果相同
    cout<<"a:"<<a<<"   "<<"&a[0][0]:"<<&a[0][0]<<endl;
    cout<<"a+1:"<<a+1<<"   "<<"&a[1][0]:"<<&a[1][0]<<endl;
    cout<<"*a+1:"<<*a+1<<"   "<<"&a[0][0]+1:"<<&a[0][0]+1<<"   "<<"&a[0][1]:"<<&a[0][1]<<endl;
    

    总结:在二维数组中数组名依旧可以表示整个数组和首元素地址,而二维数组其实可以看做是以“每行元素组成的数组”组成的一个大数组(所以列表示了小数组的元素个数,行表示了大数组的元素个数),故首元素即为 a[0] 这个数组,这个数组的首地址即为 a[0][0] 地址。因此,单独输出a得到的结果和 &a[0][0] 一致。所以a既可以表示一个小数组中的元素地址,又表示了大数组中元素的地址,这样如果用指针指向,那么+1的含义就会产生歧义,所以采用了不同的定义方式加以区分。

    最近学到的就这么多,C++路漫漫其修远兮,在整个梳理过程中还有很多感觉不精细的地方,虽然说上面很多地方都说的过于精细到没必要的地步,有只要稍稍运行一下就可以得出的结论,但还是写了,是防止我在复习的时候没有想到这个问题,如此说来,在学习中永远保持清晰的思路,能够迅速找出相似的不同并大胆实验,加以区分才是最重要的。给自己加个油,下午期末考试!

    展开全文
  • 数组的维

    千次阅读 2017-12-06 17:48:41
    作为参数或者在二维数组的声明时,往往可以省略第一维,但是不可以省略第... 由此可以看出在定义二维数组或更高维数组时,进行初始化可以省略第一维参数,编译器会根据你初始化语句自动决定第一维度,其后维数


           作为参数或者在二维数组的声明时,往往可以省略第一维,但是不可以省略第二维,或者是更高的维数。这是由于编译器的原理所限制的。

           &a[i][j]=&a[0][0]+i*sizeof(int)*n +sizeof(int );//此时n为二维的维数

        由此可以看出在定义二维数组或更高维数组时,对其进行初始化可以省略第一维参数,编译器会根据你的初始化语句自动决定第一维度,其后的维数不可省略!!!另外,一位数组和二维数组在内存中的分布是一样的,如 char a[10][10],char b[100],故将其进行sizeof的结果也是一样的。

     

         在这里有一个问题,很疑惑在初始化二维字符串数组时,字符串是如何分布的?因为由于每个字符串的长度都不等,而且还有编译器的不同问题,那么它是按照这里面最大的那个字符串来指定字符数组长度呢还是为每一个字符串“量身定做”,用’\0’结尾分布内存呢??????菜puppy啊。。。

             “整型二维数组从头到位就只有一个指针,整型一维,二维也好,数组都是连续存放的,知道头指针就可以知道后面每个元素的位置。但是字符二维数组就不止一个指针了,它是真的实现二维的指针,即一个根指针指向一个指针数组,然后数组的每一个元素(都是字符指针)分别对应格子的字符串首个字符的地址。”——摘自大佬的秘籍分享。

            







    展开全文
  • 数组

    2018-01-20 15:04:58
    维数组初始化格式 int a[10]={2,4,5,3,5,3}; 没有全部赋值时,方法后面4个元素默认为0;方括号里面数字所见即所得,是一个含有10个元素数组; 3.起泡法10个数排序(从小到大) 思路:第一轮第一次将第一...
  • 数组学习总结

    2018-12-23 17:42:00
    一、一位数组定义及初始化 定义:数组是一种具有相同类型变量集合。 使用一个数组首先要进行定义,在定义语句中声明数组元素类型以及下标个数,下标个数代表...二、二维数组的定义及初始化 一维数组...
  • c语言数组总结

    2018-12-22 16:34:28
    1.数组定义:使用一个数组首先要进行定义,在定义语句中要声明数组元素类型和下标个数,下标个数代表数组维数。(注意:C语言中数组下标是从0开始;数组大小不能用变量定义,必须用常量。) 2.一...
  • 使用vector来定义一个矩阵(二维数组),初始化,并其属性进行输出 这是一个例子 # include<vector> # include <iostream> int main() { using namespace std; vector<vector<int>&...
  • JAVA基础语法数组.docx

    2020-09-03 22:03:27
    JAVA基础语法数组 一 选择题 1 以下能对二维数组 a进行正确初始化的语句是 int a[2][] = ( {1 , 0 , 1) , (5,2,3) ) int [][] a = ( { 1, 2, 3 , ( 4, 5, 6 ) int a[2][4] = ( { 1 , 2,3 , ( 4,5 ) , ( 6 ) int [] a...
  • 1. 引用数组元素时, 其数组下标的数据类型允许是 整型常量或...3. 以下能对二维数组a 进行正确初始化的语句是: A) int a[2][]={{1,0,1},{5,2,3}}; B) int a[][3]={{1,2,3},{4,5,6}}; C) int a[2][4]={{1...
  • 深度遍历及应用

    2018-03-17 10:25:53
    我们往往需要构造出一个图用来描述实际问题,我们在描述图时,建立一个二维数组表示节点之间关系即可,不用像原来先对二维数组进行初始化(表示两点之间没有路),然后调用方法利用边集数组进行对数组实际赋值,...
  • 牛客网错题收集(3)

    2020-03-30 09:40:08
    下列字符数组进行初始化的语句正确的是? 正确答案: A 你的答案: A (正确) char a[] =“Hello”; char a[][]={‘H’,‘e’,‘l’,‘l’,‘o’}; char a[5]= “Hello”; char a[2][5]={ “Hello”,“World”}; 解释...
  • 指针变量指针变量定义指针变量引用指针与数组指针与一维数组指针与二维数组指向二维数组的行指针指向二维数组的列指针 指针变量 指针变量定义 指针变量定义一般形式: 类型 *指针变量名 符号*在变量声明...
  • js基础练练手(

    2020-06-20 21:20:03
    以下能维数组 a 进行正确初始化的语句是() A. int a[10]={0, 0, 0, 0, 0}; B.int a[10]={ }; C.int a[]={0}; D.int a[10]={10*a}; 解答: 数组的初始化: 1、a[10] = {1,2,3};//随后元素补零 2、a[] ...
  • PHP-封装MySQL单例

    2020-03-27 14:15:26
    1.9 封装MySQL单例 1.8.1 分析 1、实现单例 2、连接数据库 3、数据进行操作 ...​ a) 返回二维数组 ​ b) 返回一维数组 ​ c)返回一行一列 1.8.3 代码实现 第一步:实现单例 <?php class ...
  • 6.2.3 二维数组的初始化 6.2.4 二维数组程序举例 6.3 字符数组 6.3.1 怎样定义字符数组 6.3.2 字符数组的初始化 6.3.3 怎样引用字符数组中元素 6.3.4 字符串和字符串结束标志 6.3.5 字符数组输入输出 6.3.6 使用...
  • 7.2.3 二维数组的初始化 87 7.2.4 二维数组程序举例 89 7.3 字符数组 89 7.3.1 字符数组定义 89 7.3.2 字符数组的初始化 89 7.3.3 字符数组引用 90 7.3.4 字符串和字符串结束标志 91 67.3.5 字符数组输入输出 ...
  • 封装MySQL单例 ...​ a) 返回二维数组 ​ b) 返回一维数组 ​ c)返回一行一列 三、 代码实现 第一步:实现单例 <?php class MySQLDB { private static $instance; private function __construc
  • 【单选题】中国第一位会计师是( )。【判断题】公路运输尤其适于长距离、高价值产品的装运,在中间产品和轻工...【单选题】以下不能对二维数组 a 进行正确初始化的语句是【单选题】上臂围是指()【填空题】写出下列程...
  • c++ 程序设计

    2019-01-20 22:53:37
    5.3.3 二维数组的初始化 5.3.4 二维数组程序举例 5.4 用数组名作函数参数 5.5 字符数组 5.5.1 字符数组定义和初始化 5.5.2 字符数组赋值与引用 5.5.3 字符串和字符串结束标志 5.5.4 字符数组输入输出 5.5.5 ...
  • 【练习2】

    2020-06-27 11:42:54
    1、以下程序的输出结果是? #include <stdio.h> main() { char a[10]={ '1','2','3','4','5','6','7','8','9',0},*p;...2、以下能对二维数组a进行正确初始化的语句是() A int ta[2][]={{0,1,2},{3,4,5}};
  • (1)指针变量初始化的方法 int a; int *p=&a; (2)赋值语句的方法 int a; int *p; p=&a; 不允许把一个数赋予指针变量,故下面的赋值是错误的: int *p;p=1000; 被赋值的指针变量前不能再加“*”说明符,如写为*p=&a 也...
  • 1.31 对于没有显式初始化的变量的初始值可以作怎样的假定?如果一个全局变量初始值为“零”,它可否作为空指针或浮点零? 47 1.32 下面的代码为什么不能编译? intf(){char a[]="Hello, world!";} 47 *1.33 下面的...
  • 1.31 对于没有显式初始化的变量的初始值可以作怎样的假定?如果一个全局变量初始值为“零”,它可否作为空指针或浮点零? 1.32 下面的代码为什么不能编译? intf(){char a[]="Hello, world!";} 1.33 下面的初始化有...
  • 1.31 对于没有显式初始化的变量的初始值可以作怎样的假定?如果一个全局变量初始值为“零”,它可否作为空指针或浮点零? 1.32 下面的代码为什么不能编译? intf(){char a[]="Hello, world!";} 1.33 下面的初始化有...
  • 1.31 对于没有显式初始化的变量的初始值可以作怎样的假定?如果一个全局变量初始值为“零”,它可否作为空指针或浮点零?  1.32 下面的代码为什么不能编译?intf(){chara[]="Hello,world!";}  *1.33 下面的初始...
  • 初始化 1.31 对于没有显式初始化的变量的初始值可以作怎样的假定?如果一个全局变量初始值为“零”,它可否作为空指针或浮点零? 1.32 下面的代码为什么不能编译?intf(){chara[]="Hello,world!";} *1.33 下面...
  • 三子棋小游戏

    2017-04-16 14:22:24
    游戏设计与实现过程简单讲解。  游戏话就要有菜单让人选择玩或是退出。这样就至少要有两个选择,那么就可以用到switch分支语句了。...棋盘进行初始化。将棋盘每一个格子设置为存放一个空格‘ ’,既方...

空空如也

空空如也

1 2 3 4 5
收藏数 87
精华内容 34
关键字:

对二维数组进行初始化的语句