一维数组的定义和一维数组的引用
 
内存中一串连续的存储单元（变量），叫数组。指针移动和比较只有在一串连续的数组中才有意义。
 
当数组中每个变量只带一个下标时，为一维数组。
 
定义一个一维数组：
 
类型名 数组名【常量表达式】  如：int a[8];
 
说明： ①定义一个一维整型名为a的数组。
 
           ②方括号中规定此数组有8个元素，（a【0】-a【7】），不存在a【8】这个元素。
 
           ③a数组中每个元素均为整型，且每个元素只能存放整型。
 
           ④每个元素只有一个下标，且第一个元素的下标总为0。
 
           ⑤c编译程序，为a数组开辟8个连续存储单元。
 
3）在定义数组语句中，可以有多个数组说明符；它们用逗号隔开。
 
例：double a【22】，v【100】，u【5】，a，b，c；  注：双精度型 每个单元占用8个字节的存储空间。另外，也可以和普通变量一起定义。
 
 
用逗号分隔开。
 
 
 
一维数组元素的引用2
 
1）
 
引用形式：数组名 【下标表达式】可以是：常量，变量，表达式。
 
如：double x【8】  则   x【0】  x【j】  x【i+k】均合法
 
2）
 
（1）一个数组元素实际上就是一个变量名，代表内存中的一个存储单元。我们可以把数组元素看做一个变量名来处理。
 
（2）一个数组不能整体引用，数组名中存放的是一个地址常量，它代表整个数组的首地址。当学习指针时，引用的变量的地址，就是变量中第一个字节的地址。数组的首地址也是它的第一个元素的第一个字节的地址，即它的首地址。
 
数组的首地址存放在数组名中。所以说，数组名就代表一个地址。数组名是一个地址值。
 
（3）在引用数组元素时，数组元素下标表达式必须是整数，下标表达式下限为0.系统并不自动检验数组元素下标是否越界，因此编程时要注意。
 
如：double a,b; int c[10];
 
      a=2.0;b=3.0;
 
  则a[i]; 是不合法的。
 
 
 
给数组赋初值时，如果所赋初值少于元素个数时，后面的元素补为0，字符补为’\0’
 
可以通过赋初值来定义一个数组的大小。如：int a[]={0,0,0,0,0};  相当于：a[5]={0};
 
 
 
一维数组的初始化
 
void main()
 
{
 
      int i,j,a[30];
 
      for (i=0,j=1;i<30;i++,j+=2)
 
      a[i]=j;
 
      for (i=0;i<30;i++)
 
      {
 
           if (i%10==0)  printf(“\n”); /*i等于10，到了十，输入回车。因为0-9就是十个*/
 
printf(“%d, ”,a[i]);
 
      }
 
for (i=29;i>=0;i--)
 
{
 
printf(“%d, ”,a[i]);
 
if (i%10==0) printf(“\n”);      /*先输出第i=20这个元素，再输入回车。*/
 
}
 
getch();
 
}

#C语言 一维数组的定义和引用
 
A. 一维数组的定义与初始化
 1.几个概念
 数组名
 数组长度
 数组下标运算符
 数组维数
 数组的基类型
 2. 定义格式
 格式：类型 数组名[常量表达式]
 如 int a[100] /一维数组
 char str[200]
 
PS:数组元素的下标要从0开始， 
最大下标是元素个数-1
 
B.数组说明中常见错误
 1.float a[0] ; //数组大小为0没有意义
 2.int b(2)(3); //不能使用圆括号
 3.int k,a[k]; //不能用变量说明数组大小
 4. int n；
 5. scanf （“%d”，&n）；
 int a[n];
 //C语言不允许对数组的大小进行动态说明
 数组的说明语句必须再可执行语句之前
 6.例子
 输入以下程序
 
#include <stdio.h>
int main()
{
	int i,m[5],sum=0;
	for(i=3;i<5;i++)
	{
		scanf("%d",&m[i]);
		sum+=m[i];
		printf("Out:m[%d]=%d\n",i,m[i]);
	}
	printf("%d\n",sum);
 }                        
 
当输入下标在指定范围内时，正常输出，当下标越界时，会生成一个随机数，输入如下：
 
4
Out:m[3]=4
5
Out:m[4]=59

--------------------------------
Process exited after 6.271 seconds with return value 2
请按任意键继续. . .
 
这种下标越界的错误，计算机时无法识别的，越界后系统不会报错，故需特别注意。
 
C.数组的初始化
 1.初始化格式：
 数据类型 数组名[常量表达式]={初值1，初值2，…}
 例子：
 int a[5]={1,2,3,4,5}; /说明：数组a有5个数组元素，分别是a[0],a[1],a[2],a[3],a[4].
 int a[5]={1,2}; /说明：将数组a前两个数组元素分别赋值为1，2，其余元素为0.
 int a[]={1,2,3} /说明：数组a的大小根据元素数来决定
 
2.例子
 
#include <stdio.h>
int main()
{
	int m[]={1,2,3};
	int i,sum=0;
	for(i=0;i<3;i++)
	{
		sum+=m[i];
		printf("%d\n",m[i]);
	}
	printf("%d\n",sum);
 }                        
 
输出
 
1
2
3
6
 
当全部不赋值时，则会生成随机数
 
#include <stdio.h>
int main()
{
	int m[5];
	int i,sum=0;
	for(i=0;i<3;i++)
	{
		sum+=m[i];
		printf("%d\n",m[i]);
	}
	printf("%d\n",sum);
 }                        
 
输出
 
0
0
40
40

 
文章目录
 
1_Java语言基础(数组概述和定义格式说明)(了解)
1.2_Java语言基础(数组的初始化动态初始化)(掌握)
1.3_Java语言基础(Java中的内存分配以及栈和堆的区别)
1.4_Java语言基础(数组的内存图解1一个数组)(掌握)
1.5_Java语言基础(数组的内存图解2二个数组)(了解)
1.6_Java语言基础(数组的内存图解3三个引用两个数组)(了解)
1.7_Java语言基础(数组的初始化静态初始化及内存图)(掌握)
1.8_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)
1.9_Java语言基础(数组的操作1遍历)(掌握)
1.10_Java语言基础(数组的操作2获取最值)(掌握)
1.11_Java语言基础(数组的操作3反转)(掌握)
1.12_Java语言基础(数组的操作4查表法)(掌握)
1.13_Java语言基础(数组的操作5基本查找)(掌握)
  
2_Java语言基础(二维数组概述和格式1的讲解)(了解)
2.2_Java语言基础(二维数组格式1的内存图解)(了解)
2.3_Java语言基础(二维数组格式2的讲解及其内存图解)(了解)
2.4_Java语言基础(二维数组格式3的讲解及其内存图解)(了解)
2.5_Java语言基础(二维数组练习1遍历)(掌握)
2.6_Java语言基础(二维数组练习2求和)(掌握)
2.7_Java语言基础(思考题Java中的参数传递问题及图解)(掌握)
 

 
1_Java语言基础(数组概述和定义格式说明)(了解)
 
 
A:为什么要有数组(容器)
 
  
为了存储同种数据类型的多个值
 
 
B:数组概念
 
  
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
 
 
C:数组定义格式
 数据类型[] 数组名 = new 数据类型[数组的长度];
 
 
1.2_Java语言基础(数组的初始化动态初始化)(掌握)
 
A:什么是数组的初始化 
  
就是为数组开辟连续的内存空间，并为每个数组元素赋予值
 
B:如何对数组进行初始化 
  
a:动态初始化 只指定长度，由系统给出初始化值 
    
int[] arr = new int[5];
 
b:静态初始化 给出初始化值，由系统决定长度
 
C:动态初始化的格式： 
  
数据类型[] 数组名 = new 数据类型[数组长度];
 
D:案例演示 
  
输出数组名称和数组元素
整数类型:byte,short,int,long默认初始化值都是0
浮点类型:float,double默认初始化值都是0.0
布尔类型:boolean默认初始化值false
字符类型:char默认初始化值’\u0000’
char在内存中占的两个字节,是16个二进制位
\u0000,每一个0其实代表的是16进制的0,那么四个0就是代表16个二进制位
 
 
public static void main(String[] args) {
		//数据类型[] 数组名 = new 数据类型[数组长度];
		int[] arr = new int[5];				//动态初始化,在内存中开辟连续的5块空间

		System.out.println(arr[0]);			//系统给出默认初始化值,整数类型的都是0
											
		arr[0] = 10;

		System.out.println(arr[0]);	

		System.out.println(arr);			//[I@19bb25a
	}
 
1.3_Java语言基础(Java中的内存分配以及栈和堆的区别)
 
A:栈(掌握) 
  
存储局部变量 :定义在方法声明上和方法中的变量
 
B:堆(掌握) 
  
存储new出来的数组或对象
 
C:方法区 
  
面向对象部分讲解
 
D:本地方法区 
  
和系统相关
 
E:寄存器 
  
给CPU使用
 
 
1.4_Java语言基础(数组的内存图解1一个数组)(掌握)
 
A:画图演示 
  
一个数组
 
 
 
1.5_Java语言基础(数组的内存图解2二个数组)(了解)
 
A:画图演示 
  
二个不同的数组
 
 
 
1.6_Java语言基础(数组的内存图解3三个引用两个数组)(了解)
 
A:画图演示 
  
三个引用，有两个数组的引用指向同一个地址
 
 
 
1.7_Java语言基础(数组的初始化静态初始化及内存图)(掌握)
 
A:静态初始化的格式： 
  
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式： 
    
数据类型[] 数组名 = {元素1,元素2,…};
 
 
B:案例演示 
  
对数组的解释
输出数组名称和数组元素
 
C:画图演示 
  
一个数组
 
 
 
1.8_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)
 
A:案例演示 
  
a:ArrayIndexOutOfBoundsException:数组索引越界异常 
    
原因：你访问了不存在的索引。
 
b:NullPointerException:空指针异常 
    
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
int[] arr = {1,2,3};
arr = null;
System.out.println(arr[0]);
 
 
 
1.9_Java语言基础(数组的操作1遍历)(掌握)
 
A:案例演示 
  
 
数组遍历：就是依次输出数组中的每一个元素。
 
 
数组的属性:arr.length数组的长度
 
 
数组的最大索引:arr.length - 1;
 
  public static void print(int[] arr) {
  	for (int i = 0;i < arr.length ;i++ ) {
  		System.out.print(arr[i] + " ");
  	}
  }
 
 
 
1.10_Java语言基础(数组的操作2获取最值)(掌握)
 
A:案例演示 
  
 
数组获取最值(获取数组中的最大值最小值)
 
  public static int getMax(int[] arr) {
  	int max = arr[0];
  	for (int i = 1;i < arr.length ;i++ ) {			//从数组的第二个元素开始遍历
  		if (max < arr[i]) {							//如果max记录的值小于的数组中的元素
  			max = arr[i];							//max记录住较大的
  		}
  	}

  	return max;
  }
 
 
 
1.11_Java语言基础(数组的操作3反转)(掌握)
 
A:案例演示 
  
 
数组元素反转(就是把元素对调)
 
  public static void reverseArray(int[] arr) {
  	for (int i = 0;i < arr.length / 2 ; i++) {
  		//arr[0]和arr[arr.length-1-0]交换
  		//arr[1]和arr[arr.length-1-1]交换
  		//arr[2]和arr[arr.lentth-1-2]
  		//...

  		int temp = arr[i];
  		arr[i] = arr[arr.length-1-i];
  		arr[arr.length-1-i] = temp;
  	}
  }
 
 
 
1.12_Java语言基础(数组的操作4查表法)(掌握)
 
A:案例演示 
  
 
数组查表法(根据键盘录入索引,查找对应星期)
 
  public static char getWeek(int week) {
  	char[] arr = {' ','一','二','三','四','五','六','日'};		//定义了一张星期表
  	return arr[week];											//通过索引获取表中的元素
  }
 
 
 
1.13_Java语言基础(数组的操作5基本查找)(掌握)
 
A:案例演示 
  
 
数组元素查找(查找指定元素第一次在数组中出现的索引)
 
  public static int getIndex(int[] arr,int value) {
  	for (int i = 0;i < arr.length ;i++ ) {				//数组的遍历
  		if (arr[i] == value) {							//如果数组中的元素与查找的元素匹配
  			return i;
  		}
  	}
  	return -1;
  } 
 
 
 
2_Java语言基础(二维数组概述和格式1的讲解)(了解)
 
A:二维数组概述
B:二维数组格式1 
  
int[][] arr = new int[3][2];
 
C:二维数组格式1的解释
D:注意事项 
  
a:以下格式也可以表示二维数组 
    
1:数据类型 数组名[][] = new 数据类型[m][n];
2:数据类型[] 数组名[] = new 数据类型[m][n];
 
B:注意下面定义的区别
 
  int x;
  int y;
  int x,y;
  
  int[] x;
  int[] y[];
  
  int[] x,y[];	x是一维数组,y是二维数组
 
 
E:案例演示 
  
定义二维数组，输出二维数组名称，一维数组名称，一个元素
 
 
2.2_Java语言基础(二维数组格式1的内存图解)(了解)
 
A:画图演示 
  
画图讲解上面的二维数组名称，一维数组名称，一个元素的值的问题
 
 
 
2.3_Java语言基础(二维数组格式2的讲解及其内存图解)(了解)
 
A:二维数组格式2 
  
int[][] arr = new int[3][];
 
B:二维数组格式2的解释
C:案例演示 
  
讲解格式，输出数据，并画内存图
 
 
 
2.4_Java语言基础(二维数组格式3的讲解及其内存图解)(了解)
 
A:二维数组格式3 
  
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
 
B:二维数组格式3的解释
C:案例演示 
  
讲解格式，输出数据，并画内存图
 
 
 
2.5_Java语言基础(二维数组练习1遍历)(掌握)
 
A:案例演示 
  
需求：二维数组遍历
 
外循环控制的是二维数组的长度，其实就是一维数组的个数。 
  
 
内循环控制的是一维数组的长度。
 
  int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

  for (int i = 0;i < arr.length ;i++ ) {			//获取到每个二维数组中的一维数组
  	for (int j = 0;j < arr[i].length ;j++ ) {	//获取每个一维数组中的元素
  		System.out.print(arr[i][j] + " ");
  	}

  	System.out.println();
  }
 
 
 
2.6_Java语言基础(二维数组练习2求和)(掌握)
 
A:案例演示
 
  需求：公司年销售额求和
  某公司按照季度和月份统计的数据如下：单位(万元)
  第一季度：22,66,44
  第二季度：77,33,88
  第三季度：25,45,65
  第四季度：11,66,99
  
  int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

  int sum = 0;									//定义变量,记录每次相加的结果
  for (int i = 0;i < arr.length ;i++ ) {			//获取每一个一维数组
  	for (int j = 0;j < arr[i].length ;j++ ) {	//获取每一个一维数组中的元素
  		sum = sum + arr[i][j];					//累加
  	}
  }

  System.out.println(sum);
 
 
2.7_Java语言基础(思考题Java中的参数传递问题及图解)(掌握)
 
A:案例演示
 
  看程序写结果，并画内存图解释
  public static void main(String[] args) {
  	int a = 10;
  	int b = 20;
  	System.out.println("a:"+a+",b:"+b);
  	change(a,b);
  	System.out.println("a:"+a+",b:"+b);

  	int[] arr = {1,2,3,4,5};
  	change(arr);
  	System.out.println(arr[1]);
  }

  public static void change(int a,int b) {
  	System.out.println("a:"+a+",b:"+b);
  	a = b;
  	b = a + b;
  	System.out.println("a:"+a+",b:"+b);
  }

  public static void change(int[] arr) {
  	for(int x=0; x<arr.length; x++) {
  		if(arr[x]%2==0) {
  			arr[x]*=2;
  		}
  	}
  }
 

#include<iostream>

using namespace std;

#include<stdlib.h>

void main()

{


 int a[10] = { 1,2,3,4,5,6,7,8,9,10 };


 int(&ra)[10](a);//一维数组的引用


 int i = 1;


 for (auto data : ra)


 {


 data += i;


 //i++;


 cout << data << endl;


 }


 system("pause");


}
其中int(&ra)[10](a);就是对一维数组的引用。引用就是给原来的变量起了一个别名。




void main()

{


 int a[2] [5]= { 1,2,3,4,5,6,7,8,9,10 };


 int(&ra)[2][5](a);//二维数组的引用


 system("pause");


}
其中int(&ra)[2][5](a);是对二维数组的引用
void main()
{
 int(*p)(int a, int b)(jia);//定义一个函数指针
 cout << p(1, 2) << endl;
 int(*&rp)(int a, int b)(p);//定义函数指针的引用
 rp = jian;
 cout << p(1, 2) << endl;
 system("pause");

}
其中int(*p)(int a, int b)是定义一个函数指针，int(*p)(int a, int b)(jia)是一个初始化了的函数指针
int(*&rp)(int a, int b)(p)是对函数指针的引用，并且用函数指针p初始化

这种（）只有在初始化的时候使用，赋值的时候还是需要使用赋值号=；




void change(int(*&rp)(int, int))//函数指针的引用做参数；
{
 rp = jian;

}
int(*&changep(int(*&rp)(int, int)))(int, int)//函数指针的引用做参数且返回函数指针的引用
{
 rp = jian;
 return rp;

}
具体步骤：int（*&）（int，int）这是一个框架，因为要返回一个函数指针的引用，所以将
changep(int(*&rp)(int, int))放入*&后面形成返回值，得到int(*&changep(int(*&rp)(int, int)))(int, int)



int &p[4] = { &a,&b,&c };//引用数组是非法的，引用数组的意思就是一个引用数组里面都是引用
int *p[4] = { &a,&b,&c };//指针数组是允许的，指针数组的意思是一个指针数组里面都是引用