精华内容
下载资源
问答
  • 还学习数组类型数组的定义和初始化,以及对数组名特殊含义的理解。 1.数组元素定义初为a[0](一个代表下标个数为1) 2.c语言数组的下标都是从0开始的。 3.最好把幻数定义成宏常量(或const常量),当需要修改常数...

    对于数组部分知识点的学习,主要需要掌握:计算平均分、最高分、成绩排序与查询等等,主要向函数传递一维数组和二维数组的方法。还学习数组类型、数组的定义和初始化,以及对数组名特殊含义的理解。
    1.数组元素定义初为a[0](一个代表下标个数为1)
    2.c语言中数组的下标都是从0开始的。
    3.最好把幻数定义成宏常量(或const常量),当需要修改常数时,只需要修改宏定义(或const常量的定义)即可。例int score[5];改成int score[SIZE];头文件加 #define SIZE 5
    4.在定义数组时不能使用变量定义数组的大小。即不能这样 int score[n];!可以为整形常量。
    5.do{…}while(…)容错基质(保证正确才进行)
    6.说明、定义数组时,元素个数一定为常量。
    7.从数组所有第一个所有所占字节清0:memsent(a,0,sizeof(a));头文件要加#include
    8.一维数组:类型 数组名[元素个数],二维数组:类型 数组名[第一维长度][第二维长度]
    9.一维数组在内存中占用的字节数为:数组长度×sizeof(基类型),二维数组占用的字节数为:第一维长度×第二维长度×sizeof(基类型)。在不同的编译系统中,int型所占的字节数是不同的。用sizeof运算符来计算一个类型或者变量在内存中所占的字节数才是最准确可靠的方法,也有利于提高程序的可移植性。
    10.数组第二维的长度声明永远都不能省略,因为在连续存储空间中是按行存放的。
    11.若要把一个数组传递给一个函数,那么只要使用不带方括号的数组名作为函数实参调用函数即可。例:ReadScore(score,n);
    aver = Average(score,n);
    12.由于数组名代表数组第一个元素的地址,因此用数组名作函数实参实际上是将数组的首地址传给被调函数,
    13.数组做函数形参时,数组的长度可以不出现在数组名后面的方括号内,通常用另一个整型形参来指定数组的长度。
    14.当一个元素是未知,要求其所关联元素,不妨以负值作为输入结束的标记值。(标记控制的循环),这样的话,当输入值为负值,则结束输入,返回上一行。
    15.三种排序:
    ①交换排序:借鉴了求最大值,最小值的思想,按升序排列的基本过程为:先将第一个数分别与后面的数进行比较,若后面是的数小,则交换和第一个数的位置,否则不交换:这一轮结束之后,则求除了一个最小的放在第一个位置,然后进行第二轮比较,但这种交换效率低
    package cho2;
    public class changeSort {
    public static void main(String[] args) {
    // TODO 自动生成的方法存根
    //对给定的数组进行排序
    int[] a={53,54,56,51};
    int i;
    int j;
    int temp=0;
    //注意不要数组越界 如果i小于4或者j小于5都会有越界的
    //现象
    //注意交换中不能时时刻刻用i+1代替j;
    for(i=0;i<3;i++){
    for(j=i+1;j<4;j++){
    if(a[i]>a[j]){
    temp=a[i];
    a[i]=a[j];
    a[j]=temp;
    }}}
    for(i=0;i<4;i++){
    System.out.println(a[i]);
    }}}
    ②冒泡排序:将相邻两个数进行交换,重复的过程,一般,如果有N个数进行排序,则需进行N-1起泡
    package cho2;
    public class maopao {
    public static void main(String[] args) {
    // TODO 自动生成的方法存根
    int[] a={53,54,56,51};
    int i;
    int j;
    int m=0;
    int temp=0;
    for(i=0;i<3;i++){
    m=m-1;
    //4+m主要为了减少运行的次数
    for(j=0;j<4+m;j++){
    if(a[j]>a[j+1]){
    temp=a[j];
    a[j]=a[j+1];
    a[j+1]=temp;
    }}}
    for(i=0;i<4;i++){
    System.out.println(a[i]);
    }}}
    ③选择排序:在交换排序的基础上,找出余下的数中的最大值再与地I+1个数进行交换,这样每一轮比较中最多只有一次交换操作,这个算法最多只有N—1次交换操作
    package cho2;
    public class selectSort {
    public static void main(String[] args) {
    // TODO 自动生成的方法存根
    int[] a={53,54,56,51};
    int i;
    int j;
    int k;
    int temp=0;
    for(i=0;i<3;i++){
    k=i;
    for(j=i+1;j<4;j++){
    if(a[i]>a[j]){
    k=j;
    }}
    if(k!=i){
    temp=a[k];
    a[k]=a[i];
    a[i]=temp;
    }}
    for(i=0;i<4;i++){
    System.out.println(a[i]);
    }}}
    16.查找
    ①线性查找(顺序查找)
    条件:不要求数据表已经排好序。
    工作原理:
    一. 从线性数据表中的第一个(或最后一个)记录开始查找;
    二. 依次将记录的关键字与查找关键字进行比较 ;
    (当某个记录的关键字与查找关键字相等时,即查找成功 )
    (反之,查完全部记录都没有与之相等的关键字,则查找失败 )
    ②折半查找(二分查找法)
    条件:1:必须采用顺序存储结构,对于链表不适合:2:必须按照关键字大小有序排列.
    具体的算法思想:对于数组进行比较的时候,比较数组大小的中间值,当发现数据大于该中心数据,就在后面的一个区间进行比较,如果小于该中心数据,就在前面一个区间进行比较,在新的区间里,再次使用之前的大小中间比较法,比较,直到最后找到该数据为止。
    17.当形参为一维数组时,形参列表中数组的方括号内可以为空。为二维数组时,可以省略数组第一维的长度声明,但不能省略数组第二维的长度声明。
    针对自身情况,在本章学习中对一维数组和二维数组的定义与关系需要更好地去掌握好。

    展开全文
  • 数组是一种类型,它有三个要素,即基本类型(数组元素的类型),大小(当数组被说明为不完整类型时除外),数组的值(整个数组的值)。你可以用一个指针指向整个数组的值: char a[MAX]; /*arrayOfMAXcharacters*/ char *...

    1.实参与形参的区别

    函数的参数分为形参和实参两种。形参出现在函数定义中,在整个函数体内都可以使用,离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也不能使用。形参和实参的功能是作数据传送。发生函数调用时,主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送。 
    函数的形参和实参具有以下特点: 
    a. 形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。 
    b. 实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使实参获得确定值。 
    c. 实参和形参在数量上,类型上,顺序上应严格一致,否则会发生类型不匹配”的错误。 
    d. 函数调用中发生的数据传送是单向的。即只能把实参的值传送给形参,而不能把形参的值反向地传送给实参。 因此在函数调用过程中,形参的值发生改变,而实参中的值不会变化。

    2.什么是数组

    简单说,数组就是许多相同类型的变量的集合。类型是什么,类型是某一类的值的集合。数组是一种特殊的类型,数组的"地址"是首地址,他的值也是首地址。虽然值相同但是类型是不同的。比如 int a[3] = {1,2,3} ,sizeof(a)是12,因为a是一个数组。sizeof(&a)是4因为&a是一个数组指针也是指针变量所以是4。

    3.什么是指针

    指针其实就是存有地址的变量,和其他变量一样,也有着自己的类型,唯一的区别就是,指针在定义时需要加一个*号,比如,int *p, 在32位的编译器下,指针都是4个字节。指针身为变量,当然也可以进行正常的加减,但是它与普通变量的运算不同的是,指针的加减 所加所减的是指针所指向的类型。对于指向数组的指针,我们称之为数组指针,需要注意的是,数组的数组名代表数组首个元素的地址。因此,在某些场合我们可以将数组名当作一个指针看待,但是在使用数组名作为一个指针的时候,一定不能疏忽它与真正的指针之间的不同之处。

    4.数组作为参数传递给函数时,可以通过sizeof得到数组的大小吗?

    当把数组作为函数的参数时,你无法在程序运行时通过数组参数本身告诉函数该数组的大小,因为函数的数组参数相当于指向该数组第一个元素的指针。这意味着把数组传递给函数的效率非常高,也意味着程序员必须通过某种机制告诉函数数组参数的大小。为了告诉函数数组参数的大小,人们通常采用以下两种方法:
    第一种方法是将数组和表示数组大小的值一起传递给函数,例如memcpy()函数就是这样做的:
        memcpy( dest,source,length );
    第二种方法是引入某种规则来结束一个数组,例如在C语言中字符串总是以ASCII字符NUL('/0')结束,而一个指针数组总是以空指针结束。

    5.为什么要小心对待位于数组后面的那些元素的地址呢?
         假如你的程序是在理想的计算机上运行,即它的取址范围是从00000000到FFFFFFFF,那么你大可以放心,但是,实际情况往往不会这么简单。
        在有些计算机上,地址是由两部分组成的,第一部分是一个指向某一块内存的起始点的指,针(即基地址),第二部分是相对于这块内存的起始点的地 址偏移量。这种地址结构被称为段地址结构,子程序调用通常就是通过在栈指针上加上一个地址偏移量来实现的。采用段地址结构的最典型的例子是基于Intel 8086的计算机,所有的MS-DOS程序都在这种计算机上运行(在基于Pentium芯片的计算机上,大多数MS-DOS程序也在与8086兼容的模式下运行)。即使是性能优越的具有线性地址空间的RISC芯片,也提供了寄存器变址寻址方式,即用一个寄存器保存指向某一块内存的起始点的指针,用另一个寄存器保存地址偏移量。
        假如你的程序使用段地址结构,而在基地址处刚好存放着数组a0(即基地址指针和&a0[0]相同),这会引出什么问题呢?既然基地址无法(有效地)改变,而偏移量也不可能是负值,因此“位于a0[0]前面的元素”这种说法就没有意义了,ANSIC标准明确规定引用这个元素的行为是没有定义的。
        同样,假如数组a(其元素个数为MAX)刚好存放在某段内存的尾部,那么地址&a[MAX]就是没有意义的,假如你的程序中使用了&a[MAX],而编译程序又要检查&a[MAX]是否有效,那么编译程序必然就会报告没有足够的内存来存放数组a。
        尽管在编写基于Windows,UNIX或Macintosh的程序时不会碰到上述问题,但是C语言不仅仅是为这几种情况设计的,C语言必须适应各种各样的环境,例如用微处理器控制的烤面包炉,防抱死刹车系统,MS-DOS,等等。严格按C语言标准编写的程序能被顺利地编译并能服务于任何目的,但是,有时程序员也可以适度地背离C语言的标准,这要视程序员、编译程序和程序用户三者的具体要求而定。

    6.可以把另外一个地址赋给一个数组名吗?
        不可以,尽管在一个很常见的特例中好象可以这样做。
        数组名不能被放在赋值运算符的左边(它不是一个左值,更不是一个可修改的左值)。一个数组是一个对象,而它的数组名就是指向这个对象的第一个元素的指针。    
        假如一个数组是用extern或static说明-的,则它的数组名是在连接时可知的一个常量,你不能修改这样一个数组名的值,就象你不能修改7的值一样。
        给数组名赋值是毫无根据的。一个指针的含义是“这里有一个元素,它的前后可能还有其它元素”,一个数组名的含义是“这里是一个数组中的第一个元素,它的前面没有数组元素,并且只有通过数组下标才能引用它后面的数组元素”。因此,假如需要使用指针,就应该使用指针。

    7.字符串和数组的区别
        数组的元素可以是任意一种类型,而字符串是一种非凡的数组,它使用了一种众所周知的确定其长度的规则。
        有两种类型的语言,一种简单地将字符串看作是一个字符数组,另一种将字符串看作是一种非凡的 类型。C属于前一种,但有一点补充,即C字符串是以一个NUL字符结束的。数组的值和数组中第一个元素的地址(或指向该元素的指针)是相同的,因此通常一个C字符串和一个字符指针是等价的。
        一个数组的长度可以是任意的。当数组名用作函数的参数时,函数无法通过数组名本身知道数组的大小,因此必须引入某种规则。对字符串来说,这种规则就是字符串的最后一个字符是ASCII字符“NUL('\0')”。
        在C中,int类型值的字面值可以是42这样的值,字符的字面值可以是“*”这样的值,浮点型值的字面值可以是4.2el这样的单精度值或双精度值。

    8.用数组名做函数参数与用数组元素作实参的区别
      a.用数组元素作实参时,只要数组类型和函数的形参变量的类型一致,那么作为下标变量的数组元素的类型也和函数形参变量的类型是一致的。因此,并不要求函数的形参也是下标变量。换句话说,对数组元素的处理是按普通变量对待的。用数组名作函数参数时,则要求形参和相应的实参都必须是类型相同的数组,都必须有明确的数组说明。当形参和实参两者类型不一致时,机会发生错误。
      b.用普通变量或下标变量作函数参数时,形参变量和实参变量都是由编译系统分配的两个不同的内存单元。在函数调用时进行的值传递是把实参变量的值赋予形参变量。在用数组名做函数参数时,不是进行值的传递,即不是把实参数组的每一个元素的值都赋予形参数组的各个元素。因为实际上形参数组并不存在,编译系统不为形参数组分配内存。那么,数据的传递是如何实现的?因为数组名就是数组的首地址。因此用数组名做函数参数时所进行的传递实际上是地址的传递,也就是把实参数组的首地址赋予形参数组名。形参数组名取得该首地址后,也就等于有了具体的地址。实际上是形参数组和实参数组为同一数组,共同使用一段内存空间。

    9.array_name和&array_name的区别
        前者是指向数组中第一个元素的指针,后者是指向整个数组的指针。
        注意:笔者建议读者读到这里时暂时放下本书,先写一下指向一个含MAX个元素的字符数组的指针变量的说明。提示:使用括号。希望你不要敷衍了事,因为只有这样你才能真正了解C语言表示复杂指针的句法的奥秘。下面将介绍如何获得指向整个数组的指针。
        数组是一种类型,它有三个要素,即基本类型(数组元素的类型),大小(当数组被说明为不完整类型时除外),数组的值(整个数组的值)。你可以用一个指针指向整个数组的值:
        char  a[MAX];    /*arrayOfMAXcharacters*/
        char    *p;      /*pointer to one character*/
        /*pa is declared below*/
        pa=&al
        p=a;             /* =&a[0] */
        在运行了上述这段代码后,你就会发现p和pa的打印结果是一个相同的值,即p和pa指向同一个地址。但是,p和pa指向的对象是不同的。
        以下这种定义并不能获得一个指向整个数组的值的指针。
        char *(ap[MAX]);
        上述定义和以下定义是相同的,它们的含义都是“ap是一个含MAX个字符指针的数组。
        char *ap[MAX];

    10.参数的传递

    参数传递有传值和传地址两种方式。

    传值的过程:
    (1)行参与实参各占一个独立的存储空间。
    (2)行参的存储空间是函数被调用时才分配的。调用开始,系统为行参开辟一个临时
    存储区,然后将各实参之值传递给行参,这时行参就得到了实参的值。
    (3)函数返回时,临时存储区也被撤销。
    传值的特点:单向传递,即函数中对行参变量的操作不会影响到调用函数中的实参变量。

    地址传递方式:参数是地址
    void change_by_address(int *x){
        *x=*x+10;
    }
    实参和行参共享一个存储单元,对行参的操作相应的就改变了实参,此时参数传递是双向的。
    此外,参数的存储位置和变量的存储属性对参数传递也有影响,变量的存储属性有动态变量、静态变量
    外部变量,动态变量有2种,自动(auto)和寄存器(register)变量。

    此外还应注意内存的分配方式,内存分配方式有三种:
    (1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的
    整个运行期间都存在。例如全局变量,static 变量。
    (2) 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函
    数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集
    中,效率很高,但是分配的内存容量有限。
    (3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意
    多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存
    期由我们决定,使用非常灵活,但问题也最多。

    展开全文
  • C 语言支持数组数据结构,它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。 数组的声明并不是声明一个个单独的变量,而是声明一个数组变量,...

    C 数组

    C 语言支持数组数据结构,它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。

    数组的声明并不是声明一个个单独的变量,而是声明一个数组变量,然后使用 numbers[0]、numbers[1]、…、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。

    所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素,最高的地址对应最后一个元素。
    在这里插入图片描述
    注:要清楚数组中索引是从零开始的

    声明数组

    在 C 中要声明一个数组,需要指定元素的类型和元素的数量,如下所示:

    type arrayName [ arraySize ];
    

    这叫做一维数组。arraySize 必须是一个大于零的整数常量,type 可以是任意有效的 C 数据类型。例如,要声明一个类型为 double 的包含 10 个元素的数组 a,声明语句如下:

    double a[10];
    

    现在 a 是一个可用的数组,可以容纳 10 个类型为 double 的数字。

    初始化数组

    在 C 中,您可以逐个初始化数组,也可以使用一个初始化语句,如下所示:

    double a[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
    

    大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

    如果您省略掉了数组的大小,数组的大小则为初始化时元素的个数。因此,如果:

    double a[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
    

    你将创建一个数组,它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例:

    a[4] = 50.0;
    

    上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引,也被称为基索引,数组的最后一个索引是数组的总大小减去 1。

    访问数组元素

    数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内,跟在数组名称的后边。例如:

    double salary = a[9];
    

    上面的语句将把数组中第 10 个元素的值赋给 salary 变量。下面的实例使用了上述的三个概念,即,声明数组、数组赋值、访问数组:

    #include <stdio.h>
     
    int main ()
    {
       int n[ 10 ]; /* n 是一个包含 10 个整数的数组 */
       int i,j;
     
       /* 初始化数组元素 */         
       for ( i = 0; i < 10; i++ )
       {
          n[ i ] = i + 100; /* 设置元素 i 为 i + 100 */
       }
       
       /* 输出数组中每个元素的值 */
       for (j = 0; j < 10; j++ )
       {
          printf("Element[%d] = %d\n", j, n[j] );
       }
     
       return 0;
    }
    

    当上面的代码被编译和执行时,它会产生下列结果:

    Element[0] = 100
    Element[1] = 101
    Element[2] = 102
    Element[3] = 103
    Element[4] = 104
    Element[5] = 105
    Element[6] = 106
    Element[7] = 107
    Element[8] = 108
    Element[9] = 109
    
    展开全文
  • 若将有限个类型相同的变量的集合命名,那么这个名称为数组名。 数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按无序的形式组织起来的一种形式。[1]这些无序排列的同类数据元素的集合称为数组。 2...

    1、什么是数组

    若将有限个类型相同的变量的集合命名,那么这个名称为数组名。

    数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按无序的形式组织起来的一种形式。 [1]  这些无序排列的同类数据元素的集合称为数组。

    2、声明数组

    数组的声明并不是声明一个个单独的变量,比如number0,bumber1……,而是声明一个数组,比如numbers,然后使用number[0],number[1]……来单独代表一个个单独的变量。(数组中的元素是可以通过索引来进行访问的)。

    (所有的数组都是以 0 作为它们第一个元素的索引,也被称为基索引,数组的最后一个索引是数组的总大小减去 1)

    c语言声明数组,需要指明元素的类型和元素的数量,一维数组的所示如下:

    type arrayName [arraySize];

    arraySize 必须是一个大于零的整数常量,type 可以是任意有效的 C 数据类型。

    例如:

    int a[10]; 说明整型数组a,有10个元素。若要表示第10个元素,则使用a[9]。第一个则是a[0]。

    float b[10],c[20]; 说明实型数组b,有10个元素,实型数组c,有20个元素。

    char ch[20]; 说明字符数组ch,有20个元素。

    3、数组的初始化(以char类型的数组为例)

    3.1  初始化时候不指明数组的大小,则数组的大小则为初始化时候元素的个数

    #include <stdio.h>
    int main()
    {
    	char cBufLen[] = {'a', 'b', 'c'};
    	printf("sizeof(cBufLen)=%d\n", sizeof(cBufLen)); //返回的值是3,因为有三个元素
    }

    3.2 初始化时候,指明数组的大小,大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

         1	#include <stdio.h>
         2	int main()
         3	{
         4		char cLessThanBuf[4] = {'a', 'b', 'c'};
         5		char cEqualThanBuf[4] = {'a', 'b', 'c', 'd'};
         6		char cGreatThanBuf[4] = {'a', 'b', 'c', 'd', 'e'};
         7	}
    
    
    /*******************以下为出错显示*********************/
    getDataFromBuf.c: 在函数‘main’中:
    getDataFromBuf.c:7:2: 警告:数组初始值设定项中有多余的元素 [默认启用]
      char cGreatThanBuf[4] = {'a', 'b', 'c', 'd', 'e'};
    /*****************************************************/

    3.3 给char类型数组赋值的方式有:

    char cBufOne[4] = {'a', 'b', 'c', 'd'};
    char cBufTwo[4] = {"abcd"};

    4、访问数组

    数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内,跟在数组名称的后边。例如:数组名[元素索引值]

    为数组中某个元素赋值。直接把值赋给数组元素即可。

    #include <stdio.h>
    #include <string.h>
    
    int main()
    {
    	char cBufOne[4] = {'a', 'b', 'c', 'd'};
    	printf("cBufOne[0]=%d cBufOne[1]=%d\n", cBufOne[0],cBufOne[1]);	
    	cBufOne[1] = 'e';  //左值为数组元素的表示方式 //此行代码作用为数组中的某个元素赋值
    	printf("cBufOne[0]=%d cBufOne[1]=%d\n", cBufOne[0],cBufOne[1]);	
    	printf("%d %d\n", cBufOne[0],cBufOne[1]);	
    }
    
    /***********************以下为编译结果显示内容*********************/
    [root@localhost tool]# ./getDataFromBuf 
    cBufOne[0]=97 cBufOne[1]=98
    cBufOne[0]=97 cBufOne[1]=101
    /****************************************************************/

    上面的语句将把数组中第 10 个元素的值赋给 salary 变量。下面的实例使用了上述的三个概念,即,声明数组、数组赋值、访问数组:

    5、来个示例。声明一个大小为4的char类型数组,给数组赋值,并访问数组。

    /*****************************************
     *Function:声明一个大小为4的char类型数组,给数组赋值,并访问数组
     *Parameter:
     *Return Value:
     *Remarks:
     * ******************************************/
    
    #include <stdio.h>
    
    int main()
    {
    	/*声明数组*/
    	char cBuf[4];  /*cBuf是一个包含4 个char类型的数组*/
    	int i = 0;
    	int j = 0;
    	
    	/*初始化数组*/
    	for(i = 0; i < 4; i++)
    	{
    		cBuf[i] = 'a' + i; /* 设置元素i为 i + 'a'*/
    	}
    
    	/*访问数组元素*/
    	for(j = 0; j < 4; j++)
    	{
    		printf("cBuf[%d] = %d\n", j, cBuf[j]);
    	}
    	return 0;	
    }
    
    
    /**************************结果显示如下**************/
    [root@localhost tool]# ./array 
    cBuf[0] = 97
    cBuf[1] = 98
    cBuf[2] = 99
    cBuf[3] = 100
    /***************************************************/

    6、探讨数组初始化时候,大括号 { } 之间的值的 小于 数组声明时在方括号 [ ] 中指定的元素数目,其余值赋值为什么?

    #include <stdio.h>
    
    int main()
    {
    	/*声明数组 and 初始化数组*/
    	char j = 0;
    	char cBuf[4] = {"ab"};
    
    	/*访问数组元素*/
    	for(j = 0; j < 4; j++)
    	{
    		printf("cBuf[%d] = %d\n", j, cBuf[j]);
    	}
    	return 0;	
    }
    
    /*************以下为结果显示******************/
    [root@localhost tool]# ./array 
    cBuf[0] = 97
    cBuf[1] = 98
    cBuf[2] = 0
    cBuf[3] = 0
    /******************************************/
    
    //解释说明:查看ascii码发现,没被直接复制的数组元素被赋值为'\0'
           Oct   Dec   Hex   Char                  
           ────────────────────────────────
           000   0     00    NUL '\0'                

     

    展开全文
  • C语言数组用法大全

    2020-11-07 21:37:07
    数组的地址是它的首字节的地址 静态数组:指的是长度固定的数组(fixed arrays) 变长数组:长度不固定的数组(variable arrays),变长数组不能初始化 #include<stdio.h> int main(void) { int n;
  • C语言指针引用数组

    千次阅读 2020-10-16 21:32:54
    前言:C语言中指针玩的是什么,是内存,要想学好指针的小伙伴们要先对数据在内存中是怎么玩的做一番了解~       当在程序中定义一个变量时,系统会根据其数据类型为其开辟内存空间,...
  • C语言学习时,学到数组与指针的联系时,我们讲到数组是一种特殊的指针,特殊在哪呢? 数组在定义时,如int a[10],即开辟了特定的内存空间来存放数组中的元素,数组起到一个容器的作用,可通过访问容器的地址给...
  • C语言中的数组越界

    千次阅读 2014-11-03 22:31:48
    因为C语言不检查数组越界,而数组又是我们经常用的数据结构之一,所以程序中经常会遇到数组越界的情况,并且后果轻者读写数据不对,重者程序crash。下面我们来分析一下数组越界的情况: 结合我的另外一篇文章 C语言...
  • 一、 数组的基本概念数组是可以在内存中连续存储多个元素的结构//就像是多个int绑定在一起了,数据类型不一定非要是int也可以是其他的数据类型数组中的所有元素必须属于相同的数据类型//说是int就要大家都是int,...
  • (四):数组作为参数传递给函数时,不可以通过sizeof得到数组的大小 (五):指针比带下标的数组名访问元素更高效 (六):不能将另外一个地址赋给一个数组名 (七):array_name是指向数组中第一个元素的指针,&...
  • 严格来说,C语言中并没有直接创建动态数组的方法。 但在 stdlib 库中提供了 几个创建动态存储区的函数,通过调用这些函数, 可以让我们实现创建动态数组...要注意该指针的基类型是void,即不指向任何类型的数据。 # in
  • 注意:数组指针的定义,与指针数组的区别 ... 指向多维数组元素的指针变量 ...这里采用的方法是用基类型为整型的指针变量先后指向各元素,逐个输出它们的值。 #include <iostream> using name...
  • 数据结构之数组C语言实现)

    千次阅读 2018-06-05 15:24:18
    数组是大家很熟悉的一种数据类型,而且在我们的程序设计中也应用非常广泛。这里以抽象数据类型的形式讨论数组的定义和实现。一、数组的定义假设n维数组中含有第i维的长度为b(i),则数组的总长度为b(0) *b(1)*...*b(n...
  • C语言数组赋值一例

    千次阅读 2014-02-28 16:42:29
    在移植内核时,发现一个驱动使用数组十分巧妙。 一般地,操作CPU某一外设寄存,不是直接使用完整的地址,而是通过...如果有七、八个定时器,只需要定义好一个地址数组、一个偏移地址数组,通过不同的序号就能访问不
  • 文章目录一、静态数组和动态数组1.静态数组的缺点2.动态内存分配与动态数组2.1 动态内存分配2.2 动态数组2.3 内存与堆与栈二、自定义函数返回数组1.常见错误2.返回数组的函数三. 总结四. 参考 提示:以下是本篇文章...
  • C语言数组指针 作为形参

    千次阅读 2015-06-05 21:33:48
    在修改程序的过程中,看到两种将数组作为形参的方法,于是搜了一下,找了一下比较全面地介绍数组指针的文章。 先写下我遇到的两种方式: 方式1: void filter_c(long double *,long double *,float *,int);//函数...
  • 结构体数组 每个数组元素都是一个结构体类型的数据就是结构体数组 定义结构体数组一般形式: struct 结构体名{成员表列}数组名[数组长度]...结构体变量指针的基类型必须与指向的结构体变量类型相同 struct A{ int
  • C语言数组

    2018-12-22 11:39:16
    1,一维数组的定义和初始化:  数组是一组具有相同类型的变量的集合。使用一个统一的名字来标识这组相同类型的数据,这个名字称为数组名,构成... 注意:C语言数组的下标都是从0开始的。如果对一个数组而言,例...
  • C语言

    万次阅读 多人点赞 2019-12-18 23:01:50
    46.用c语言编写程序,可以编写出任何类型的程序 47.C语言允许有空函数 48.C程序书写格式,允许一行内可以写几个语句 49.C程序的语句无行号 50.C语言的每个语句的最后必须有一个分号 51.C语言本身没有输入...
  • c语言数组和指针

    2017-07-28 20:33:46
    数组的定义:数组是一块“同类型”且“连续”的存储空间 1.定义 类型 数组名[长度] 注:长度为常量 2.初始化 定义时并赋初始值 eg:int buf[4]={1,2,3,4}; 3.引用:取出变量内容 数组引用元素是从下表为0开始的 ...
  • 基类型 数组长度 定义一个有10个int型元素的一维数组 下标从0开始 未初始化数组元素:自动初始化为0值,否则,是随机数 数组的数据类型:每一元素占内存空间的字节数 一维数组如何赋值: 例子 int a[4]= {1,2,3,4}; ...
  • 2.18 既然数组名可以用作数组地址,为什么对结构不能这样? 2.19 程序运行正确,但退出时却“coredump”(核心转储)了,怎么回事? 联合 2.20 结构和联合有什么区别? 2.21 有办法初始化联合吗? 2.22 有...
  • C语言数组(基本)

    2020-01-03 15:26:55
    它的类型称为数组。 一维数组 声明数组 data_type array_name[number_of_elements]; 例如: int arr[1000], 这是声明了一个具有1000个int元素的数组。可以想象如果C不支持集合变量,如果要声明的话,我们只能声明1000...
  • 字符串数组的引用(C语言实现)

    千次阅读 2019-09-13 10:14:15
    2.字符串的实现: 因为C语言中只提供字符数据类型,没有提供字符串数据类型,所有C语言中的 字符串是通过字符数组来实现的。所有表示字符串数组的最后一个元素都是空字符(ASCII码值为0的字符’\0’) 3.字符串的...
  • 新手必知之c语言一维数组与指针

    千次阅读 2019-01-26 12:41:56
    指针p的基类型是int,数组a的各个元素也是int类型的。我们用p=&amp;amp;amp;a[0],将指针p指向数据元素a[0]。由于数组元素在内存中是连续的,因此我们可以通过移动指针p来访问数组中的每一个元素。 (2...
  • C语言数组的小知识

    2018-01-22 19:50:29
     1、格式 类型(int char float long short 等) 数组名 [数字、常量表达式];eg int a[10];常量表达式不能是变量,即不能对数组大小进行动态定义 2、引用 数组名【下标】eg a[2] = 5;数组的一个元素相当于一个...
  • C语言编程常见问题解答之数组

    千次阅读 2013-08-20 16:42:54
    (隔段时间不看就会在实际使用中忘记掉---c语言数组、异或指针的使用),转载一下,忘时供查询  C语言处理数组的方式是它广受欢迎的原因之一。C语言对数组的处理是非常有效的,其原因有以下三点:  第一,除少数...
  • 通过赋初值定义二维数组的大小 第一种: 例如:int a[][3] = {{1, 2, 3}, {4, 5}, {6}, {8}}; 注意: 对于二维数组,省略只能省略第一个方括号中的常量表达式 如上的初赋值语句等同于: int a[4][3] = {{1...
  • 2.1 C语言数组与指针

    2019-01-02 15:10:51
     指针和指针的减法运算有意义:间隔距离是多少个单位(基类型宽度)  指针和整数的加减运算有意义:以基类型宽度为单位移动指针    定义为数组,声明为指针;定义为指针,声明为数组,这两种都是错误的.  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,350
精华内容 4,140
关键字:

c语言数组基类型是啥

c语言 订阅