精华内容
下载资源
问答
  • C语言数组赋值一例

    2020-07-16 16:18:22
    从这里学习到一个数组赋值的方法,即实际赋值可以按不同的顺序(只要是合法的下标),而不是仅限于从0~N这样的顺序去赋值
  • 很多学生在学习C语言时,在数组的地方会有点困惑。 1.数组必须指定长度,而其数组定义的长度不能是变量或者浮点数,一定是常量表达式; 2.数组赋值,有两种,一是在定义的时候就进行初始化,或者单个引用来赋值...

    很多学生在学习C语言时,在数组的地方会有点困惑。

    1.数组必须指定长度,而其数组定义的长度不能是变量或者浮点数,一定是常量表达式;

    2.数组的赋值,有两种,一是在定义的时候就进行初始化,或者单个引用来赋值。

    但有个问题:

    #include <stdio.h>
    
    int main(void)
    {
    	int a[5] = {1,2,3,4,5};
    	a[5] = 10;
    	printf("a[5] = %d\n",a[5]);
    	return 0;
    }

    结果:

    a[5] = 10
    Press any key to continue

    上述代码编译没有问题,但代码写的是错误的

    数组长度为5,元素只有a[0]-a[4],没有a[5]元素。但为什么给a[5]赋值没有报错或告警呢?另外这个值到底赋给了谁呢?

    我们可以同变量的地址来发现问题。

    代码:

    #include <stdio.h>
    
    int main(void)
    {
    	int i = 0;
    	int b[5];
    	int a[5] = {1,2,3,4,5};
    	a[5] = 10;
    	for(i=0;i<5;i++)
    	{
    		printf("数组a[%d]的地址 = %X\n",i,&a[i]);
    	}
    	for(i=0;i<5;i++)
    	{
    		printf("数组b[%d]的地址 = %X\n",i,&b[i]);
    	}
    	printf("数组a[5]的地址 = %X\n",&a[5]);
    	return 0;
    }

    结果:

    数组a[0]的地址 = 19FF04
    数组a[1]的地址 = 19FF08
    数组a[2]的地址 = 19FF0C
    数组a[3]的地址 = 19FF10
    数组a[4]的地址 = 19FF14
    数组b[0]的地址 = 19FF18
    数组b[1]的地址 = 19FF1C
    数组b[2]的地址 = 19FF20
    数组b[3]的地址 = 19FF24
    数组b[4]的地址 = 19FF28
    数组a[5]的地址 = 19FF18
    Press any key to continue

    你会发现a[5]的地址和b[0]的地址一样,所以在给a[5] = 10;时实际上是篡改了b[0]中的内容,我们可以试一下:

     代码:

    #include <stdio.h>
    
    int main(void)
    {
    	int i = 0;
    	int b[5];
    	int a[5] = {1,2,3,4,5};
    	a[5] = 10;
    	for(i=0;i<5;i++)
    	{
    		printf("数组a[%d]的地址 = %X\n",i,&a[i]);
    	}
    	for(i=0;i<5;i++)
    	{
    		printf("数组b[%d]的地址 = %X\n",i,&b[i]);
    	}
    	printf("数组a[5]的地址 = %X\n",&a[5]);
    
    	printf("数组a[5]的值 = %d\n",a[5]);
    	printf("数组b[0]的值 = %d\n",b[0]);
    	return 0;
    }

    结果为:

    数组a[0]的地址 = 19FF04
    数组a[1]的地址 = 19FF08
    数组a[2]的地址 = 19FF0C
    数组a[3]的地址 = 19FF10
    数组a[4]的地址 = 19FF14
    数组b[0]的地址 = 19FF18
    数组b[1]的地址 = 19FF1C
    数组b[2]的地址 = 19FF20
    数组b[3]的地址 = 19FF24
    数组b[4]的地址 = 19FF28
    数组a[5]的地址 = 19FF18
    数组a[5]的值 = 10
    数组b[0]的值 = 10
    Press any key to continue
    

    可以明显看出a[5]的赋值实质上修改了b[0]的值,这个对于初学者来说是大忌,在以后的开发过程中会经常出现这样的问题,这种问题属于踩内存,贼不好定位。所以大家在学习时一定要注意!!!!

    数组的长度为N,那数组元素只能有0~N-1个元素

     

     

    展开全文
  • 没有a[4]元素,但经过程序验证,发现a[4]不仅存在还可以正常赋值,这样似乎不合理,那到底是哪地方出问题了? 问了解决这一问题,我们可以看一下数组元素的地址: #include void main() { int a[4] = {1,2,3,4}; int...

    先来看一个例子,请大家看一下有没有问题?

    #include<stdio.h>
    
    void main()
    {
    	int a[4] = {1,2,3,4};
    	a[4] = 5;
    	printf("a[4] = %d\n",a[4]);
    }

    结果:

    a[4] = 5
    Press any key to continue

     程序执行无错误无警告,编译环境选择的是VC++6.0。

    疑问:书上明确说,数组的元素从0开始一直到数组长度-1,如int a[4],那么它的元素就有a[0],a[1],a[2],a[3]。没有a[4]元素,但经过程序验证,发现a[4]不仅存在还可以正常赋值,这样似乎不合理,那到底是哪地方出问题了?

    问了解决这一问题,我们可以看一下数组元素的地址:

    #include<stdio.h>
    
    void main()
    {
    	int a[4] = {1,2,3,4};
    	int i = 0;
    	a[4] = 5;
    	printf("a[4] = %d\n",a[4]);
    	printf("a[4]的地址 = %X\n",&a[4]);
    }

    结果:

    a[4] = 5
    a[4]的地址 = 19FF30
    Press any key to continue

    现在再来定义一个数组,int b:

    #include<stdio.h>
    
    void main()
    {
    	int b[4] = {0};
    	int a[4] = {1,2,3,4};
    	
    	int i = 0;
    	a[4] = 5;
    	printf("a[4] = %d\n",a[4]);
    	printf("a[4]的地址 = %X\n",&a[4]);
    	printf("b[0]的地址 = %X\n",&b[0]);
    }

    结果:

    a[4] = 5
    a[4]的地址 = 19FF20
    b[0]的地址 = 19FF20

    Press any key to continue

    你会分析,a[4]的地址和b[0]的地址一样,这就发现问题所在了,现在修改了a[4]的值,相当于修改了b[0]的值,代码验证如下:

    #include<stdio.h>
    
    void main()
    {
    	int b[4] = {0};
    	int a[4] = {1,2,3,4};
    	
    	int i = 0;
    	a[4] = 5;
    	printf("a[4] = %d\n",a[4]);
    	printf("a[4]的地址 = %X\n",&a[4]);
    	printf("b[0]的地址 = %X\n",&b[0]);
    	printf("b[0] = %d\n",b[0]);
    }

    结果:

    a[4] = 5
    a[4]的地址 = 19FF20
    b[0]的地址 = 19FF20
    b[0] = 5
    Press any key to continue
    可以清楚的看到,b数组的第一个元素值被a[4]修改,这个是不合理的。所以,可以得出一个结论:书上讲的没错,数组元素的个数,是从0开始,整个元素个数不超过数组长度

    最后,这里提醒大家,这样的操作要不得,你会发现明显在踩内存,使得数组b的值无辜被修改。相信以后编译器可以在第一时间爆出问题,不然这个问题引入,问题很难定位。

    学习一直在路上,加油!!!!

    展开全文
  • 一、数组赋值 数组名就代表着该数组的首地址,后面的所有元素都可以根据数组名加上偏移量取到。 1. 一维数组 第一个小例子:编程实现显示用户输入的月份(不考虑闰年)拥有的天数。** #include<stdio.h> #...

    一、数组赋值

    数组名就代表着该数组的首地址,后面的所有元素都可以根据数组名加上偏移量取到。

    1. 一维数组


    第一个小例子:编程实现显示用户输入的月份(不考虑闰年)拥有的天数。**

    #include<stdio.h>
    #define MONTHS 12
    int main(){
        int days[MONTHS] = {31,28,31,30,31,30,31,31,30,31,30,31};
        int month;  // 1-12
        do{
            printf("Input a month:");
            scanf("%d", &month);
        }while(month<1 || month>12);  // 处理不合法数据
        // days数组是从0-11
        printf("The number of days is %d\n", days[month-1]);  
        return 0;
    }
    

            上面这个例子我们简单的用一维数组存储了一年的年份。这个代码的功能想必题目说得很清楚了,我就不再重复赘述。中间有一段while循环的代码,那个是为了处理不合法数据的,因为当我们输入的值在1-12之间的时候,这个循环我们是出不去的,会让我们一直输入月份。
            在后面输出对应月份的天数的时候,我们用的下标是month-1,因为数组的下标是从0-11,我们输入的是1-12,所以-1后才是我们对应需要的月份。


    2. 二维数组

    一维数组比较简单,我们来看二维数组。下面是一个二维数组的小例子。

    int main(){
    	// 没有指定的位置,自动赋值为0
        int a[][3] = {{1,2,3}, {4,5}, {6}, {0}};  
        printf("%d, %d, %d\n", a[1][1], a[0][2], a[2][1]);
        return 0;
    }
    // 数组构造:
    // 1   2   3
    // 4   5   0
    // 6   0   0
    // 0   0   0
    
    Input:
    5, 3, 0
    

            这个例子我们可以看出来,这个二维数组,我们最初只是指定了列数,没有指定行数,也就是说二维数组可以只指定列数,行数可以在我们进行赋值的时候,自动确定。比如我这个例子,二维数组给定了三列,里面写了4个小的一维数组,所以最终这个二维数组的维度是4行3列


    我们再来看下面这个更有趣的例子。

    int main(){
    	// 没有指定的位置,自动赋值为0
        int a[][3] = {1, 2, 3, 4, 5, 6, 7};  
        return 0;
    }
    

            这个例子中没有一个小括号,虽然前面的定义是一个二维数组,但是里面的赋值就像一个一维数组一样,有点儿奇怪?其实他的内部是这样的。

    1   2   3
    4   5   6
    7   0   0
    

            为什么会这样?因为他指定了三列,这是毋容置疑的,但是没有指定行数,所以里面的元素会按照三列的规则一行一行的排列下去,如果排到某一行,还有空的位置没有元素,就会自动被赋值为0,这个二维数组的维度就是3行3列

    数组的奇特赋值方式我想大家已经理解了,那么我们来看 数组越界 的问题。


    二、数组越界

    1. 一维数组越界

            一维数组的越界,编译器(我使用的VC6.0)不会在你越界的提示你,而是会根据这个地址继续对该位置进行相关操作(比如赋值或者取值)。我们来看下面这个例子:

    #include<stdio.h>
    int main(){
    	int a = 1, c = 2, b[5], i;
    	printf("\na = %d, c = %d\n", a, c);
    	
    	// 这里明显对于b数组的赋值,已经越界
    	for (i=0; i<=8; i++){
    		b[i] = i;
    	}
    	
    	printf("\n a = %d, c = %d\n", a, c);
    	return 0;
    }
    

    运行结果如下:
    在这里插入图片描述
    这个 ac 的值明显被改变了,我们下面来看一下数组越界后,发生了什么:
    在这里插入图片描述
            其实编译器之所以在编译的时候没有报错,是因为他的取值赋值是根据地址来做的。由于数组名就是该数组的首地址,也就是第一个元素的地址,所以当你的索引变化的时候,虽然数组已经没有对应元素给他使用了,但是他依然会根据偏移量往后继续找,这也就把后面跟着的 c 和 a 的值给修改了。(我的编译器虽然在运行的时候没有报错,但是运行结束后还是出现了异常,提示关闭程序)

    关于偏移量,我举个简单的例子:
    比如,在C语言中 char 字符类型是占一个字节的。
    我们定义一个一维数组  char a[5];
    假设首地址是 40,那我们去 a[5] ,这个元素的地址就是 40+5*1 
    因为字符类型一个位置占一个字节。
    那个5就是偏移量,也就是说如果你定义的 int a[5],那么后面就是 40+5*4 了。
    因为在大多数编译器中 int 占4个字节,当然也有占2个字节的。
    

            上面是一维数组的越界情况。


    2. 二维数组越界

            其实这个的越界和一维数组越界原理是一样的,都是根据偏移量来取值,不同的是二维数组有多行,也就是你在这一行越界后,他会跑到下一行,我们来看下面这个例子:

    #include<stdio.h>
    int main(){
        int i, j;
        char a[6][4] = {(char)0x00};
        printf("%p\n", a);  // 输出首地址
        a[0][0] = 0x01;  // 16进制
        a[1][0] = 0x10;
        a[0][4] = 0x04; // a[1][0]
        a[1][4] = 0x05; // a[2][0]
        a[5][4] = 0x20; // 完美刚好越界
        a[5][5] = 0x30; // 越界
        for (i=0; i<6; i++){
            for (j=0; j<4; j++){
                printf("%d\t", a[i][j]);
            }
            printf("\n");
        }
        return 0;
    }
    
    Input:
    1    0    0    0
    4    0    0    0
    5    0    0    0
    0    0    0    0
    0    0    0    0
    0    0    0    0
    

            代码中的注释我们可以看到,在一个二维数组 arr[6][4]中,a[0][4] 和 a[1][0] 是同一个元素,因为 a[0][4] 在第一排越界后,根据偏移量的计算,他跑到了第二列的第一个。

    a[6][4] 是一个6行4列的二维数组,一行4个
    a[0][4] = 0*4 + 4 = 4
    a[1][0] = 1*4 + 0 = 4
    
    a[i][j] = i*4 + j
    表示前面已经走过了 4*i 个地址,然后在 i+1 行走了 j 个位置。
    计算出来就是最终的地址。
    
    对了,0x表示的十六进制的数组,比如 0x10 换算成十进制就是 16。
    因为就像16进一一样,在第二位有一个1,说明就已经有个16了。
    

            以上就是二维数组越界的情况。


    3. 下面我们看一下简单的二维数组小例子

    #include<stdio.h>
    #define MONTHS 12
    int main(){
        int days[MONTHS] = {{31,28,31,30,31,30,31,31,30,31,30,31},  // 平年
                           {31,29,31,30,31,30,31,31,30,31,30,31}};  // 闰年
        int year, month;  // 1-12
        
        do{
            printf("Input a month:");
            scanf("%d, %d", &year, &month);
        }while(month<1 || month>12);  // 处理不合法数据
        
        if (((year%4==0) && (year%100!=0)) || (year%400==0)){  /* 闰年 */
        	printf("The number of days is %d\n", days[1][month-1]);  // days数组是从0-11
        }else{  /* 平年 */
            printf("The number of days is %d\n", days[0][month-1]);
        }
        
        return 0;
    }
    
    展开全文
  • C语言 字符数组赋值

    千次阅读 2018-05-29 09:24:00
    /给数组赋字符串/ . . . } 上面程序在编译时, 遇到char s[30]这条语句时, 编译程序会在内存的某处留 出连续30个字节的区域, 并将第一个字节的地址赋给s。当遇到strcpy( strcpy 为 Turbo C2.0的函数)时, 首先在目标...

    main()
    {
    char s[30];
    strcpy(s, “Good News!”); /给数组赋字符串/
    .
    .
    .
    }
    上面程序在编译时, 遇到char s[30]这条语句时, 编译程序会在内存的某处留
    出连续30个字节的区域, 并将第一个字节的地址赋给s。当遇到strcpy( strcpy 为
    Turbo C2.0的函数)时, 首先在目标文件的某处建立一个”Good News!/0” 的字符串。
    其中/0表示字符串终止, 终止符是编译时自动加上的, 然后一个字符一个字符地复
    制到s所指的内存区域。因此定义字符串数组时, 其元素个数至少应该比字符串的
    长度多1。
    注意:
    1. 字符串数组不能用”=”直接赋值, 即s=”Good News!”是不合法的。所以应分
    清字符串数组和字符串指针的不同赋值方法。
    2. 对于长字符串, Turbo C2.0允许使用下述方法:
    例如:
    main()
    {
    char s[100];
    strcpy(s, “The writer would like to thank you for”
    ”your interest in his book. He hopes you”
    ”can get some helps from the book.”);
    .
    .
    .
    }


    指针数组赋值
     


    例如:
    main()
    {
    char *f[2];
    int *a[2];
    f[0]=”thank you”; /*给字符型数组指针变量赋值*/
    f[1]=”Good Morning”;
    *a[0]=1, *a[1]=-11; /*给整型数数组指针变量赋值*/
    .
    .
    .
    }

     

    ——————————————————————————————————————

    补充:

    无论是静态,局部还是全局数组只有在定义时才能初始话,否则必须通过其它方法,比如循环操作实现。

    任何
    int a[3];
    static int b[3];
    a[3] = {1, 2, 3};
    b[3] = {1, 2, 3};
    没有在定义时初始化都是错误的!

    ——————————————————————————————————————-

    以下是转载:
    学了这么多年的C语言,突然发现连字符串赋值都出错,真的很伤心。

    char a[10];
    怎么给这个数组赋值呢?
    1、定义的时候直接用字符串赋值
    char a[10]=”hello”;
    注意:不能先定义再给它赋值,如char a[10]; a[10]=”hello”;这样是错误的!
    2、对数组中字符逐个赋值
    char a[10]={‘h’,’e’,’l’,’l’,’o’};
    3、利用strcpy
    char a[10]; strcpy(a, “hello”);

    易错情况:
    1、char a[10]; a[10]=”hello”;//一个字符怎么能容纳一个字符串?况且a[10]也是不存在的!
    2、char a[10]; a=”hello”;//这种情况容易出现,a虽然是指针,但是它已经指向在堆栈中分配的10个字符空间,现在这个情况a又指向数据区中的hello常量,这里的指针a出现混乱,不允许!

    还有:不能使用关系运算符“==”来比较两个字符串,只能用strcmp() 函数来处理。


    C语言的运算符根本无法操作字符串。在C语言中把字符串当作数组来处理,因此,对字符串的限制方式和对数组的一样,特别是,它们都不能用C语言的运算符进行复制和比较操作。


    直接尝试对字符串进行复制或比较操作会失败。例如,假定str1和str2有如下声明:

    char str1[10], str2[10];

    利用=运算符来把字符串复制到字符数组中是不可能的:

    str1 = “abc”;     /*** WRONG ***/

    str2 = str1;       /*** WRONG ***/

    C语言把这些语句解释为一个指针与另一个指针之间的(非法的)赋值运算。但是,使用=初始化字符数组是合法的:

    char str1[10] = “abc”;

    这是因为在声明中,=不是赋值运算符。

    试图使用关系运算符或判等运算符来比较字符串是合法的,但不会产生预期的结果:

    if (str1==str2) …    /*** WRONG ***/

    这条语句把str1和str2作为指针来进行比较,而不是比较两个数组的内容。因为str1和str2有不同的地址,所以表达式str1 == str2的值一定为0。

     

     

    ————————————————————————————————————————————-

    有空再查下动态数组的定义使用:

    数组到底应该有多大才合适,有时可能不得而知。所以希望能够在运行时具有改变数组大小的能力。
    动态数组就可以在任何时候改变大小。

     

    通俗的说静态数组就是在定义数组的时候,由操作系统分配的空间,比如
    int a[10];
    这就是在定义时由系统给你分配了10个int类型的空间,这个空间是可以初始化的,比如
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    那么在这个定义之后,系统会首先分配10个int类型的存储空间,然后把大括号里面的数字分别的,按顺序放到这10个空间里。你所做的只是写这么一句,而数组赋值的操作就由系统完成了。当然,初始化与否看你的需求,初始化不是强制性操作,想初始化就初始化,不想也没问题,还是上面的例子继续:
    int a[10];
    这里定义了,但是没初始化,这没有任何问题,以后你可以自己往里面赋值,比如
    a[1] = 8;
    a[5] = 3;
    或者
    for(int i = 0; i < 10; i++)
        a[i] = i;
    等等

    对于动态数组,不能被初始化,因为动态数组在定义时只是个指针,比如
    int *a;
    这里变量a只是个指向int类型的指针,而不是数组。动态分配有10个int类型元素的数组,如下:
    a = (int) malloc(10*sizeof(int));
    很明显,指针a在定义的时候不能被初始化,比如这样写就是错误的:
    int *a = {1,2,3,4,5,6,7,8,9,10}; /* 错误! */
    因为a是只有4个字节的指针,没有可用的存储空间给需要初始化的变量。

    —————————————————————————————————————————————————-

     

    第三节  初始化数组

    1.数组的初始化

      数组可以初始化,即在定义时,使它包含程序马上能使用的值。
      例如,下面的代码定义了一个全局数组,并用一组Fibonacci数初始化:
        int iArray[10]={1,1,2,3,5,8,13,21,34,55); //初始化
        void main()
        {
          //…
        }

      初始化数组的值的个数不能多于数组元素个数,初始化数组的值也不能通过跳过逗号的方式来省略,这在C中是允许的,但在C++中不允许。
      例如,下面的代码对数组进行初始化是错误的:
        int arrayl[5]={1,2,3,4,5,6}; //error: 初始化值个数多于数组元素个数
        int array2[5]={1,,2,3,4}; //error:初始化值不能省略
        int array3[5]={1,2,3,}; //error:初始化值不能省略
        int array4[5]={}; //error:语法格式错误
        void main()
        {
          //…
        }

      初始化值的个数可少于数组元素个数。当初始化值的个数少于数组元素个数时,前面的按序初始化相应值, 后面的初始化为0(全局或静态数组)或为不确定值(局部数组)。
      例如,下面的程序对数组进行初始化:
        //*********************
        //**   ch7_2.cpp  **
        //*********************

        #include <iostream.h>

        int array1[5]={1,2,3};
        static int array2[5]={1};

        void main()
        {
         int arr1[5]={2};
         static int arr2[5]={1,2};

         int n;
         cout <<”global:/n”;
         for(n=0; n<5; n++)
           cout <<” ” <<array1[n];

         cout <<”/nglobal static:/n”;
         for(n=0; n<5; n++)
           cout <<” ” <<array2[n];

         cout <<”/nlocal:/n”;
         for(n=0; n<5; n++)
           cout <<” ” <<arr1[n];

         cout <<”/nlocal static:/n”;
         for(n=0; n<5; n++)
            cout <<” ” <<arr2[n];
         cout <<endl;

        }

      运行结果为:
        global:
         l  2  3  0  0
        global static:

         1  0  0  0  0
        local:
         2 23567 23567 23567 23567
        local static:
         1  2  0  0  0

      例中,全局数组和全局静态数组的初始化是在主函数运行之前完成的,而局部数组和局部静态数组的初始化是在进入主函数后完成的。
      全局数组arrayl[5]对于初始化表的值按序初始化为1,2,3,还有两个元素的值则按默认初始化为0。
      全局静态数组array2[5]与全局数组的初始化情况一样,初始化表值(1)表示第1个元素的值,而不是指全部数组元素都为1。
      局部数组arrl[5]根据初始化表值的内容按序初始化, 由于初始化表值只有1个,所以还有4个元素的值为不确定。在这里均为数值23567。
      局部静态数组arr2[5]先根据初始化表按序初始化,其余3个数组元素的值默认初始化为0。

    2.初始化字符数组

      初始化字符数组有两种方法,一种是:
        char array[10]={“hello”};
      另一种是:
        char array[10]={‘h’,’e’,’l’,’l’,’/0’};
      第一种方法用途较广,初始化时,系统自动在数组没有填值的位置用,’/0’补上。另外, 这种方法中的花括号可以省略,即能表示成:
        char array[10]=”hello”;
      第二种方法一次一个元素地初始化数组,如同初始化整型数组。这种方法通常用于输入不容易在键盘上生成的那些不可见字符。
      例如,下面的代码中初始化值为若干制表符:
        char chArray[5]={‘/t’,’/t’,’/t’,’/t’,’/0’)
      这里不要忘记为最后的,’/0’分配空间。如果要初始化一个字符串”hello”,那为它定义的数组至少有6个数组元素。
      例如,下面的代码给数组初始化,但会引起不可预料的错误:
        char array[5]=”hello”;
      该代码不会引起编译错误,但由于改写了数组空间以外的内存单元,所以是危险的。

    3.省略数组大小

      有初始化的数组定义可以省略方括号中的数组大小。
      例如,下面的代码中数组定义为5个元素:
        int a[]={2,4,6,8,10};
      编译时必须知道数组的大小。通常,声明数组时方括号内的数字决定了数组的大小。有初始化的数组定义又省略方括号中的数组大小时,编译器统计花括号之间的元素个数,以求出数组的大小。
      例如,下面的代码产生相同的结果:
        static int a1[5]={1,2,3,4,5};
        static int a2[]={1,2,3,4,5};

      让编译器得出初始化数组的大小有几个好处。它常常用于初始化一个元素个数在初始化中确定的数组,提供程序员修改元素个数的机会。
      在没有规定数组大小的情况下,怎么知道数组的大小呢? sizeof操作解决了该问题。 例如,下面的代码用sizeof确定数组的大小:

        //*********************
        //** ch7_3.cpp **
        //*********************

        #include <iostream.h>

        void main()
        {
         static int a[]={1,2,4,8,16};
         for(int i=0; i<(sizeof(a)/sizeof(int)); i++)
          cout <<a[i] <<” “;
         cout <<endl;
        }

      运行结果为:
        1 2 4 8 16
      sizeof操作使for循环自动调整次数。如果要从初始化a数组的集合中增删元素,只需重新编译即可,其他内容无须更动。
      每个数组所占的存储量都可以用sizeof操作来确定! sizeof返回指定项的字节数。sizeof常用于数组,使代码可在16位机器和32位机器之间移植:
      对于字符串的初始化,要注意数组实际分配的空间大小是字符串中字符个数加上末尾的,’/0’,结束符。
      例如,下面的代码定义一个字符数组:

        //*********************
        //**   ch7_4.cpp  **
        //*********************

        #include <iostream.h>

        void main()
        {
         char ch[]=”how are you”;

         cout <<”size of array: ” <<sizeof(ch) <<endl;
         cout <<”size of string: ” <<strlen(“how are you”)            <<endl;
        }


      运行结果为:
        size of array:12
        size of string:ll

      例中,数组大小为12,而字符串长度为11。
      省略数组大小只能在有初始化的数组定义中。
      例如,下面的代码将产生一个编译错误:
        int a[];//error:没有确定数组大小
      在定义数组的场合,无论如何,编译器必须知道数组的大小。

     

    展开全文
  • c语言数组动态赋值

    千次阅读 2019-01-12 19:22:34
    动态赋值法在c语言程序中有着很大的作用,比如输入几个数比较他们的大小,也可以与冒泡排序法相结合,从而使程序易于编译执行 #include &lt;stdio.h&gt;//动态赋值法,输入10个数,比较他们的大小 #include...
  • c语言 结构体数组赋值 //**创建结构体** #include<stdio.h> struct Class{ int id; char name[10]; }; //******结构体数组赋值 int main(){ int m; //定义结构体数组的长度所需变量 int i; printf(...
  • C语言之数组(数组赋值的三种形式)

    万次阅读 多人点赞 2018-07-18 22:20:34
    C语言中,对数组进行赋值的三种形式 1、通过循环的形式 即:数组名[下标] 对数组的元素进行依次赋值   #include &lt;stdio.h&gt; int main() { int i; int a[10] = {0}; for(i=0;i&lt;10;i...
  • 但是,数组,指针都是定义了之后再赋值则有规则。 目录 1.数组可以直接定义赋值字符串。如char str[128] = "dasdasdasda"; 此时的访问可以用字符串的占位符%s ,也可以用数组的 for( ) 循环访问。 2.给(数组)...
  • 动态数组的理解 动态数组可以起到节省内存空间作用,也就是随叫随到,用完...我给大家展示一个动态数组的初始化、赋值、输出、释放的代码: #include <stdio.h> #include <stdlib.h> int main(void)
  • 做了一个小的例子: #include int main() { struct Link { int LinkId; int LinkLen; int NxtLnkId; }Lnk[3]; Lnk[0].LinkId = 1;... printf("结构体数组赋值完成。"); } 结构体数组的赋值情况:
  • C语言 字符数组赋值的方法 整理

    千次阅读 2015-03-15 18:38:03
    怎么给这个数组赋值呢? 1、定义的时候直接用字符串初始化 char a[10]="hello"; 注意:不能先定义再给它赋值,如char a[10]; a[10]="hello";这样是错误的!只有定义初始化是才能这样赋值 2、对数组中字符逐个...
  • 数组之间的赋值C语言数组之间赋值详解 (biancheng.net)
  • C语言给char数组赋值问题

    千次阅读 2020-11-01 21:27:04
    使用for+scanf赋值时问题 代码: printf("请输入串长度\n"); scanf("%d", &s.length); printf("请输入串\n"); for (int i = 1; i <= s.length; i++) scanf("%c", &s.ch[i]); 结果: 串1存了...
  • 小明在学到二维数组时,尝试写了一段给二维数组赋值的代码,他发现一个奇怪的现象:交换赋值顺序,效率是不同的。交换赋值顺序,效率是不同的请看下面这两段C语言代码:版本 1int test1 (){ int i,j; static int x...
  • 关于C语言数组赋值方法

    千次阅读 2019-10-04 07:26:13
    C语言数组赋值方法 数组赋值的方法分为: 1.赋值语句--对数组元素逐个赋值 例: #include <stdio.h> int main(){  int i,a[10];  for(i = 0;i <=9;i++){  a[i]=i; /*赋值语句*/  }  for(i....
  • 今天小编就为大家分享一篇关于C语言结构体数组同时赋值的另类用法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • - 取余数失败, position数组中所有赋值都是零 - 我看了一晚上也没研究明白, 求大神指点, 感激不尽 ```c #include int main() { int num; int i = 0; int j; int position[4] = {-1, -1, -1, -1}...
  • 1、数组在定义时, 可以同时进行初始化,但...可通过数组下标方式或指针方式,引用数组元素,进行赋值。 例子: char a[10]; char ch=‘a’; for( i=0;i<10;i++ ) a[i]=ch+i ; //可通过数组下标引用数组元素,完成赋
  • c语言数组赋值

    千次阅读 2017-08-29 18:28:21
    最近在学c语言,试着给数组赋值,接下来会逐渐完善
  • 若定义了一个数组“int a[5]={1,2,3,4,5};”,又定义了一个数组“int b[5];”,那么如何编写程序才能将数组...前面说过,a 和 b 是数组名,而数组名表示的是数组“第一个元素”的“起始地址”。即 a 和 b 表示的是地...
  • C语言字符串数组赋值

    千次阅读 2019-09-13 21:16:15
    数组赋值有两种方式 一种是在定义是赋值: char book[] = {"the story of sitone"}; char author = "曹雪芹";//去掉花括号也可以 char k[5] = {'h','e','l','l','o','\0'}; 定义后在赋值就一般用strcpy,不能用=赋值...
  • C语言数组赋值

    2020-03-19 21:20:26
    想请问各位 str[]={“good”} 跟 str[]=“good”有什么区别呢?
  • char a[3];...这样是会报错的,因为数组名相当于数组的首地址,这个操作相当于对数组的首地址赋值,所以会报错。 #include <string.h> char a[3]; strcpy(a, "xxx"); 用strcpy函数就可以实现。
  • 一般情况下,对结构体类型的变量或者结构体类型的数组赋值都是先定义一个结构体类型的变量,然后在对其属性进行赋值。例如: typedef struct Pi { int x; int y; } Pc; int main() { int i; Pc pc[2]; pc[0...
  • 数组名和函数名一样本身就代表地址,是地址常量,如同&stru2 = &stru非法一样,数组名之间也无法赋值,进一步说,array是常量,而array[0]则是变量,这也是array与&array同样表示地址的原因。
  • a是一个静态数组,在C语言中其在编译期间为一个常量表达式,而常量表达式可以当做是常量来使用,所以不能对于a进行指针赋值操作,既然这样是错误的,这么对于字符数组进行赋值呢 2.字符数组单个字符的赋值操作 最...
  • C语言动态数组建立方法

    千次阅读 2017-12-07 20:37:28
    当要用它时,可随时用ReDim语句(C语言中用malloc语句)重新指出数组的大小。使用动态数组的优点是可以根据用户需要,有效利用存储空间。  动态数组,是相对于静态数组而言。静态数组的长度是预先定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 122,051
精华内容 48,820
关键字:

c语言动态数组赋值

c语言 订阅