C语言学习笔记3（数组，结构体，指针）

一、数组

1·数组的定义

        在定义的时候就是向系统申请内存空间,数组在申请空间的时候就是确定数组的长度的时候,所以长度一旦确定不能更改.

        赋值:虽然数组是一次性定义出来的,但是赋值的时候没办法一次性赋值,定义之后,数组只能一次一次赋值,那也就是说定义的时候可以一次性赋值(初始化)

一次一次赋值
int array[2];
array[0]=1;
array[1]=2;

---------------------

初始化赋值
int array[2]={1,2};

        打印输出: 整形数组输出里面的元素不然在什么时候都只能一个一个输出,没办法一条语句一次性输出

但是可以使用for循环输出
for(int n=0; n<2; n++) 
{ 
    printf("%d\n",array[n]); 
}

2·字符数组

        2.1字符数组的定义

        char array[5];//定义一个字符数组，可以存放5个字符，

        字符和数字可以互相转换

                如：printf("%d\n",'F'); ----> 70 printf("%c\n",70); ----> F

        总结： 整型int的输入输出格式：%d 

                    字符型char的输入输出格式：%c

        2.2字符数组的赋值

int array[5];

一个一个的赋值： 

array[0] = 'S'; 
array[1] = 'O'; 
array[2] = 'S'; 
array[3] = '!'; 
array[4] = '!';

----------------

for(int lp=0; lp<5; lp++) 
scanf("%c",&array[lp]);

------------------------------

一次性输入：

string scanf("%s",array);

        2.3字符数组的输出

一个一个输出： 
printf("%c",array[0]); 
printf("%c",array[1]); 
printf("%c",array[2]); 
printf("%c",array[3]); 
printf("%c",array[4]); 

------------------------

for(int lp=0; lp<5; lp++) 
{
    printf("%c",array[lp]); 
} 

----------------------------------

一次性输出： 

printf("%s\n",array);

        2.4使用sizeof动态计算数组的长度

                (sizeof和&是杂项运算符)

int array[11];     

int array_len = sizeof(array)/sizeof(int);      //sizeof(array)    44个字节  
                                               //sizeof(int)       4个字节 
for(int lp=0; lp<array_len; lp++) 
{ 
    scanf("%d",&arrap[lp]); 
}

二、结构体类型 ----- 构造类型

---

        1.结构体的特点

        数组能存放多个数据，结构体也能存放多个数组， 数组虽然可以存放多个数据,但是数组里面的数据的类型是一样.结构体就和数组不一样,结构体里面的数据的类型可以不一样.

int array[4];     可以存放4个数据,但是每一个数据都应该是int类型

        2.结构体的定义 定义类型, 定义变量

        结构体的关键字是struct,要想申请结构体对应的空间(申请结构体变量空间)需要先申请定义结构体的类型.

        具体如下: struct 类型的名字 { int a; char b; } ;       注意：这只是定义好类型,还没定义好变量所以是不占内存空间的.不像int a;就占4个字节 (数据类型不定义变量是不占空间的)

        利用实现定义好的结构体类型去定义变量(去申请内存空间)

        如下：struct 类型的名字 变量名字;         //定义了一个结构体变量---占内存空间的

        补充:类型的名字和变量名字需要符合C语言的标识符的命名规则(数字,字母,下划线组成,开头不能是数字)

例子:定义一个结构体类型里面可以存放一个整形和一个字符型,然后那这个类型去定义具体的变量

#include <stdio.h>           //定义结构体类型为全局类型 

struct xxx 
    { 
        int a; 
        char b; 
    }; 
struct xxx yy;             //定义结构体变量为全局变量 

int main() 
{                             //定义结构体类型为局部类型 
    struct xxx 
    { 
        int c; 
        char d; 
    }; 

    struct xxx yyy;        //定义结构体变量为局部变量 

    return 0; 
}

        3.结构体变量的赋值

        给结构体变量yyy的成员赋值  yyy.a = 111;    yyy.b = 'S';

输出结构体变量的成员值

printf("%d---%c\n",yyy.a,yyy.c);

结构体定义类型,定义变量,赋值并且输出的例子

#include <stdio.h> 

int main() 
{                  //定义结构体类型为局部类型 
    struct xxx 
    { 
        int a; 
        char c; 
    }; 

    struct xxx yyy;   //定义结构体变量为局部变量 

    yyy.a = 110; 
    yyy.c = 'S'; 

    printf("结构体变量yyy的a等于:%d,yyy的c等于:%c\n",yyy.a,yyy.c); 

    return 0; 
}

补充:结构体变量可以直接互相赋值(但他们的结构体类型要一致),数组变量不能互相赋值\

        4.结构体变量的地址和他的首成员的地址的关系 

        结构体变量的地址 等于 他的首成员的地址 （偏移量为0）

        5.结构体数组变量如何定义

        整型数组：int array[2];

        结构体数组： 定义结构体类型：

        struct people_inf

        {

                char pep_name[8];

                int pep_age;

                char pep_sex[8];

        };

        定义结构体数组变量： 定义一个结构体数组变量叫做yyy，

        他可以有2个结构体空间 struct xxx yyy[2];                

三、 指针

        从代码的角度来理解，指针就是变量的地址，指针就是地址，地址就是指针。有一种变量可以用来存放地址的，也就可以用来存放指针的，我们称为指针变量。

        这样理解： 整型变量用来存放整型数据的 字符变量用来存放字符数据的 指针变量用来存放地址（指针）的 但是因为变量有类型，所以变量的地址也有类型，由变量自身的类型决定。

         int a; 整型变量a &a 整型地址或者整型指针

        char b; 字符变量b &b 字符型地址 或者字符型指针

        指针有类型（地址有类型），那也就是说存放地址的变量也需要类型来区分（存放指针的变量也需要类型来区分）。指针变量就是有类型的。

        常见的指针变量有两种类型：整型指针变量和字符指针变量 也就是说存放整型变量的地址的变量我们称为整型指针变量 存放字符变量的地址的变量我们称为字符指针变量。

        定义一个整型指针变量： int * int_p; 用来存放整型变量的地址： int a = 10; int_p = &a;某一个整型变量的地址

        定义一个字符指针变量： char * char_p; 用来存放整型变量的地址： char b = 'd'; char_p = &b;某一个整型变量的地址       

        那也就是说 int_p存放了&a ,char_p存放了&b址。所以输出 int_p和输出&a的结果是一样的，同理。所以输出 char_p和输出&b的结果是一样的 

指针变量的基本作用：

        指针变量存放了其他变量的地址是有用的，可以通过其他变量的地址找到对应的变量，找对应的变量就可以对应对他进行修改，指针变量如何通过其他变量的地址找到其他变量，可以通过指针变量来更改宿主变量的值。