笔记（5）

二维数组：
int arr[2][3] = {{1,2,3｝， ｛3,5,6}};
arr == &arr[0] //数组名是数组第一个元素的首地址
arr[0] == &arr[0][0];////arr[0]是第二维的数组名,arr[0][0]的地址就是以为数组的arr[0]元素

int *p = arr[0];
int *p[2] = {arr[0],arr[1]};
int (*p1)[3] = arr;

int **p = arr[0][0];

int a, b;
int *p1, *p;
p1 = &a;
p = &p1;//*p = **p1

数组指针（指针数组）:
// int *p[2] = {arr[0], arr[1]}; // == p[0] == arr[0]
// int (p1)[3] = arr; // (*(p1+i)+j)

二级(重)指针例子：

void func(int **p)
{
}

int main()
{
    int a = 23, b = 33;
    int **p, *p1;
    p1 = &a;
    p = &p1;

    func(p);


    int *a;
    a = (int*)0x7fff1234;//非法地址

结构体struct
基本数据结构，数组是一种数据结构(缺点：元素单一)
结构体是一种数据结构,解决了数组里不能存放多种类型的数据这种缺陷。

struct infor        // struct infor 是标识符，必须整体使用
{
    char name[50];  // (元素)成员变量(属性)
    char is_male;
    int age;
};              // 分号坚决不能少

//这么写也行
//struct    data
{
    int a;
    float b;
    char c;
}s;  // 这个S是变量名的意思;定义类型的同时给出了结构体的变量名

struct st
{
    int a;
    float b;
    char c;
}; // 结构体类型

void set_value_func(struct st arr[], int lenth)
{
    int i = 0;

    for (i=0; i<lenth; i++)
    {
        scanf("%d", &arr[i].a);
        scanf("%f", &arr[i].b);
        scanf("%d", &arr[i].c);
    }
}

void show_infor_func(struct st arr[], int lenth)
{
    int i = 0;
    for (i=0; i<lenth; i++)
    {
        printf("%d %.2f %d\n", arr[i].a, arr[i].b, arr[i].c);
    }
}

void func(struct st *p)   // p = &s
{
    p->a = 1;
    p->b = 3.14;
    p->c = 2;
}

//定义了一个类型，占空间否？
typedef struct infor S; 


int main(void)
{
    //初始化,和数组很像，挨个进行赋值
    S s2 = {1, 2};

    printf("结构体元素：%s %d %d.\n", s2.name, s2.is_male, s2.age);

    S s3 = {1, 2, 3};
    printf("结构体元素：%s %d %d.\n", s3.name, s3.is_male, s3.age);

    S s4 = {"lk", 1};
    printf("结构体元素：%s %d %d.\n", s4.name, s4.is_male, s4.age);

    //初始化
    S s5 = {.age=27, .name="吕科"};

    printf("结构体元素：[%s] %d %d.\n", s5.name, s5.is_male, s5.age);

    // 56 只是你这个类型所占字节的大小
    printf("sizeof(S) = %d.\n", sizeof(S));
    //定义了一个结构体变量,你有变量，才会给你分配空间
    //初始化
//  S s = {"吕科", 1, 17};
    //遍历元素, 运算符(.)是专用于结构体变量访问个元素
//  printf("结构体元素：%d %d %s.\n", s.is_male, s.age, s.name);
/*
    S s1;       
    //赋值个成员变量
    //.符号访问到结构体的成员变量名
    strcpy(s1.name, "吕科");

    s1.is_male = 1;

    s1.age = 17;

    printf("结构体元素：%d %d %s.\n", s1.is_male, s1.age, s1.name);
*/



/*
    //结构体指针, 野指针
//  struct st *p;
    struct st s;

//  p = &s;
    //调用函数赋值
//  func(p);
    func(&s);

    printf("s.a = %d.\n", s.a);
*/
/*
    //结构体还有数组(结构体数组)
    struct st arr[3];

    set_value_func(arr, 3);
    show_infor_func(arr, 3);
*/
/*
    //该类型的变量
    struct st s;
    s.a = 1;
    s.b = 3.14;
    s.c = 2;
    //结构体里.号的实质
    //&s类型是struct st *
    int *p_a = (int *)&s;
    printf("*p_a = %d.\n", *p_a);

//  float *p_b = (float *)((char *)&s+4); // sizeof(char) * 4 = 4字节a
//  分析：地址值转化为数字，加上几就是几
    float *p_b = (float *)((long)&s+4);   // overlap
    printf("*p_b = %.2f.\n", *p_b);
    char *p_c = (char *)((char *)&s+8);
    printf("*p_c = %d.\n", *p_c);

    struct st s1;
    //相同结构体变量之间可以互相赋值.在C++里有个称呼叫做：赋值构造
    s1 = s;

    printf("s1.a = %d.\n", s1.a);
*/          

    return 0;
}



//结构体字节对齐
struct str1      // 7
{
    int a;       // 4
    char b;      // 1 + 1
    short c;     // 2
}s1; // 8

struct str2
{
    char a;     // 1
    char b;     // 1
            // + 2  
    int c;      // 4
}s2; // 8

struct str3         // 6
{
    int a;
    char b;
    char c;
            // + 2
}s3;  // 8

struct str4     // 10
{
    struct str1 s;  // 8
    char a;         // 1 + 1
    short b;       
}s4; // 12     

typedef struct str5     // 5
{
    int a;
    char b;
}ST, *p_ST;      // ST是struct str5的类型名，p_ST是struct str5 *类型的别名

struct str6     // 5
{
    char a;
    int b;
}S, *p = &S;        // S是struct str6的变量名， p是此结构体的指针变量名。

//默认是4字节对齐，最大的基本数据类型和这个默认值要相比较，取其小
struct str7
{
    char ab;
    int a[2];
//  char b;
};