——黑马程序员——一维数组的长度和越界问题

-----------android 培训 、 java培训 、java学习型技术博客、期待与您交流！-----------

一维数组的长度和越界问题

一、数组长度的计算

1、数组在内存中所占字节数取决于数据的类型和数据的个数

2、数组在内存中占用的总字节数：sizeof(数组名)；

3、数组长度 = 数组占用的总字节数 / 数组元素占用的字节数

数组的总字节数测试代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    //定义一个整型的数组
    int a[5] = {0,1,2,3,4};
    //打印整型数组的总字节数
    printf(" a[5]的总字节数为：%d\n",sizeof(a));
    
    //定义一个字符型的数组
    char ch[5] = {'A','B','C','D','E'};
    //计打印字符型数组的总字节数
    printf("ch[5]的总字节数为：%d\n",sizeof(ch));
    
    //定义一个float类型的数组
    float f[5] = {3.14f,6.28f,4.13f,6.28f,8.26f};
    printf(" f[5]的总字节数为：%d\n",sizeof(f));
    
    //定义一个double类型的数组
    double d[5] = {3.14,6.28,4.13,6.28,8.26};
    printf(" d[5]的总字节数为：%d\n",sizeof(d));
    
	system("pause");
	return 0;
}

数组的总字节数测试结果：

数组的元素所占字节数测试代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    //定义一个整型的数组
    int a[5] = {0,1,2,3,4};
    //计算数组的每个元素的字节数
    printf(" a[5]中每个元素所占字节数为：%d\n",sizeof(int));
    
    //定义一个字符型的数组
    char ch[5] = {'A','B','C','D','E'};    <pre name="code" class="html" style="color: rgb(51, 51, 51); font-size: 14px; line-height: 26px;">    //计算数组的每个元素的字节数

printf("ch[5]中每个元素所占字节数为：%d\n",sizeof(char)); //定义一个float类型的数组 float f[5] = {3.14f,6.28f,4.13f,6.28f,8.26f};

<pre name="code" class="html" style="color: rgb(51, 51, 51); font-size: 14px; line-height: 26px;">    //计算数组的每个元素的字节数

printf(" f[5]中每个元素所占字节数为：%d\n",sizeof(float)); //定义一个double类型的数组 double d[5] = {3.14,6.28,4.13,6.28,8.26};

<pre name="code" class="html" style="color: rgb(51, 51, 51); font-size: 14px; line-height: 26px;">    //计算数组的每个元素的字节数

printf(" d[5]中每个元素所占字节数为：%d\n",sizeof(double)); system("pause");return 0;}

数组的元素所占字节数测试结果：

数组长度测试代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	//定义一个整型的数组
    int a[5] = {0,1,2,3,4};
    //打印整型数组的总字节数
    printf(" a[5]总字节数为：%d\n",sizeof(a));
    //计算数组中每个元素的字节数
    printf(" a[5]中每个元素所占字节数为：%d\n",sizeof(int));
    //a[5]数组的长度
    printf("---->a[5]数组长度为：%d\n",sizeof(a)/sizeof(int));
    printf("\n");
    
    
    //定义一个字符型的数组
    char ch[5] = {'A','B','C','D','E'};
    //打印整型数组的总字节数
    printf(" ch[5]总字节数为：%d\n",sizeof(ch));
    //计算数组中每个元素的字节数
    printf("ch[5]中每个元素所占字节数为：%d\n",sizeof(char));
    //a[5]数组的长度
    printf(" ---->ch[5]数组长度为：%d\n",sizeof(ch)/sizeof(char));   
    printf("\n");    
    
    //定义一个float类型的数组
    float f[5] = {3.14f,6.28f,4.13f,6.28f,8.26f};
    //打印整型数组的总字节数
    printf("  f[5]总字节数为：%d\n",sizeof(f));
    //打印整型数组中每个元素所占字节数
    printf(" f[5]中每个元素所占字节数为：%d\n",sizeof(float));
    //f[5]数组的长度
    printf(" ---->f[5]数组长度为：%d\n",sizeof(f)/sizeof(float));    
    printf("\n");
    
    //定义一个double类型的数组
    double d[5] = {3.14,6.28,4.13,6.28,8.26};
    //打印整型数组的总字节数
    printf(" d[5]总字节数为：%d\n",sizeof(d));    
    //打印整型数组每个元素所占字节数 
    printf(" d[5]中每个元素所占字节数为：%d\n",sizeof(double));
    //d[5]数组的长度
    printf(" ---->d[5]数组长度为：%d\n",sizeof(d)/sizeof(double));    
    
    
	system("pause");
	return 0;
}

数组长度测试结果：

未指定数组长度时计算数组的长度：

测试代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	//定义一个整型的数组
    int a[] = {0,1,2,3,4,5,6,7};
    //打印整型数组的总字节数
    printf(" a[]总字节数为：%d\n",sizeof(a));
    //计算数组中每个元素的字节数
    printf(" a[]中每个元素所占字节数为：%d\n",sizeof(int));
    //a[5]数组的长度
    printf("---->a[]数组长度为：%d\n",sizeof(a)/sizeof(int));
    printf("\n");
    
    
    //定义一个字符型的数组
    char ch[] = {'A','B','C','D','E','F','G'};
    //打印整型数组的总字节数
    printf(" ch[]总字节数为：%d\n",sizeof(ch));
    //计算数组中每个元素的字节数
    printf("ch[]中每个元素所占字节数为：%d\n",sizeof(char));
    //a[5]数组的长度
    printf(" ---->ch[]数组长度为：%d\n",sizeof(ch)/sizeof(char));   
    printf("\n");    
    
    //定义一个float类型的数组
    float f[] = {3.14f,6.28f,4.13f,6.28f,8.26f,0.8f};
    //打印整型数组的总字节数
    printf("  f[]总字节数为：%d\n",sizeof(f));
    //打印整型数组中每个元素所占字节数
    printf(" f[]中每个元素所占字节数为：%d\n",sizeof(float));
    //f[5]数组的长度
    printf(" ---->f[]数组长度为：%d\n",sizeof(f)/sizeof(float));    
    printf("\n");
    
    //定义一个double类型的数组
    double d[] = {3.14,6.28,4.13,6.28,8.26,8.8,9.7,1.23,7.9};
    //打印整型数组的总字节数
    printf(" d[]总字节数为：%d\n",sizeof(d));    
    //打印整型数组每个元素所占字节数 
    printf(" d[]中每个元素所占字节数为：%d\n",sizeof(double));
    //d[5]数组的长度
    printf(" ---->d[]数组长度为：%d\n",sizeof(d)/sizeof(double));    
    
    
	system("pause");
	return 0;
}

测试结果：

测试代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	//定义一个整型的数组
    int a[100] = {0,1,2,3,4,5,6,7};
    //打印整型数组的总字节数
    printf(" a[100]总字节数为：%d\n",sizeof(a));
    //计算数组中每个元素的字节数
    printf(" a[100]中每个元素所占字节数为：%d\n",sizeof(int));
    //a[5]数组的长度
    printf("---->a[100]数组长度为：%d\n",sizeof(a)/sizeof(int));
    printf("\n");
    
    
    //定义一个字符型的数组
    char ch[50] = {'A','B','C','D','E','F','G'};
    //打印整型数组的总字节数
    printf(" ch[50]总字节数为：%d\n",sizeof(ch));
    //计算数组中每个元素的字节数
    printf("ch[50]中每个元素所占字节数为：%d\n",sizeof(char));
    //a[5]数组的长度
    printf(" ---->ch[]数组长度为：%d\n",sizeof(ch)/sizeof(char));   
    printf("\n");    
    
    //定义一个float类型的数组
    float f[30] = {3.14f,6.28f,4.13f,6.28f,8.26f,0.8f};
    //打印整型数组的总字节数
    printf("  f[30]总字节数为：%d\n",sizeof(f));
    //打印整型数组中每个元素所占字节数
    printf(" f[30]中每个元素所占字节数为：%d\n",sizeof(float));
    //f[5]数组的长度
    printf(" ---->f[30]数组长度为：%d\n",sizeof(f)/sizeof(float));    
    printf("\n");
    
    //定义一个double类型的数组
    double d[70] = {3.14,6.28,4.13,6.28,8.26,8.8,9.7,1.23,7.9};
    //打印整型数组的总字节数
    printf(" d[70]总字节数为：%d\n",sizeof(d));    
    //打印整型数组每个元素所占字节数 
    printf(" d[70]中每个元素所占字节数为：%d\n",sizeof(double));
    //d[5]数组的长度
    printf(" ---->d[70]数组长度为：%d\n",sizeof(d)/sizeof(double));    
    
    
	system("pause");
	return 0;
}

测试结果：

二、一维数组的越界问题

数组越界：当给数组初始化赋值或者访问数组元素时超出了数组的长度，访问了不能访问的地址叫越界

测试代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	printf(" int类型数组\n");
    //定义变量
    int i;
	//定义一个整型的数组
    int a[5] = {0,1,2,3,4,5};
    //遍历数组
    for(i = 0; i < 7; i++)
    {
    printf(" 元素：%d  ",a[i]);
    //数组中每个元素的地址
    printf(" 	地址：%p\n",&a[i]);
    }
    
    
    printf("float类型数组\n");           

	//定义变量
    int k;
    //定义一个float类型的数组
    float f[5] = {3.14f,6.28f,4.13f,6.28f,8.26f,0.8f};
    //遍历数组
    for(k = 0; k < 7; k++)
    {
    printf(" 元素：%f",f[k]);
    //数组中每个元素的地址
    printf(" 	地址：%p\n",&f[k]);
    }
    printf("字符类型数组\n");           

	//定义变量
    int n;
    //定义一个float类型的数组
    char ch[3] = {'A','B','C','D'};
    //数组元素
    printf(" 元素：%c",ch[0]);
    //数组地址
    printf(" 	地址：%p\n",&ch[0]);
     //数组元素
    printf(" 元素：%c",ch[1]);
    //数组地址
    printf(" 	地址：%p\n",&ch[1]);
    //数组元素
    printf(" 元素：%c",ch[22]);
    //数组地址
    printf(" 	地址：%p\n",&ch[2]);
    //数组元素
    printf(" 元素：%c",ch[3]);
    //数组地址
    printf(" 	地址：%p\n",&ch[3]);
   
    printf("double类型数组\n");
     int m;
    //定义一个double类型的数组
    double d[6] = {3.14,6.28,4.13,6.28,8.26,8.8,9.7,1.23,7.9};
     //遍历数组
    for(m = 0; m < 10; m++)
    {
    printf(" 元素：%f",d[m]);
    //数组中每个元素的地址
    printf(" 	地址：%p\n",&d[m]);
    }
    printf("\n");
    
	system("pause");
	return 0;
}

测试结果：