c语言结构体与指针

结构体：

数据经常以组的形式存在，雇主必须声明了每一位雇员的姓名，年龄和工资。如果这些值存储在一起，访问起来会变得简单一些。如果数据类型不同，我们可以用结构来吧不同类型存储起来。

struct tag{ member-list } variable-list

结构体有几种写法，例如：

1.

struct {
    int a;
    char b;
    float c;
} x;

此种写法为匿名结构体（相当于单例），创建了一个x变量，包含3个成员。

struct {
    int a;
    char b;
    float c;
} y[10], *z;

创建了y(数组),和z（指针）。

2.也可以不用声明变量列表。

struct SIMPLE{
    int a;
    char b;
    float c;
}

未来的变量可以这么声明。

struct SIMPLE x;
struct SIMPLE y[10],*z;

1. 3.

typedef struct{
    int a;
    char b;
    float c;
} Simple;

注意：typedef的意思是，类型取别名
例如：

//Age int类型的别名
typedef int Age;
//Age int类型指针的别名
typedef int* Ap;

这么声明和声明一个结构标签几乎相同，区别现在simple是一个类名，而不是一个结构体标签。所以后续标签可以是这个样子。

Simple x;
Simple y[10], *z;

如果想在多个源文件中使用同一种类型的结构，应该把标签声明和typeof形式声明放在一个头文件中。当源文件需要这个声明的时候，可以用#include 把那个头文件包含进来。

结构成员的访问

1. 用“.”访问
   假如一个声明。

struct COMPLEX comp;

访问sa

(（comp.sa）[4]).c

简写

comp.sa[4].c

2.用”->”访问
假如一个函数的参数指向结构的指针。

void func( struct COMPLEX *P);

访问这个变量所指向的结构的成员f。

cp->f

符号“->“就是 “（*cp.）”的简写。

结构体的自引用

struct SELF{
    int a;
    struct SELF b;
    int c;
}；

这种类型是不合法的，因为b是两另一个完整的结构。包含自己的成员b。第二个又是一个完整的结构包含成员b。这样就进行了死循环。
而我们定义一个指针就是合法的。编译器在结构长度确认之前就已经知道了指针的结构。

struct SELF{
    int a;
    struct SELF *b;
    int c;
}；

还有一点需要注意：

typedef struct{
    int a;
    struct SELF *b;
    int c;
}SELF；

这种是不对的。因为SELF到了末尾才定义，之前是没有定义的。
我们可以在之前加上一个名称来声明b。

typedef struct SELF_TAG{
    int a;
    struct SELF_TAG *b;
    int c;
}SELF；

结构体的初始化

struct INIT{
    int a;
    short b[10];
    Simple c;
} x= {
  10,
  {1,2,3,4,5}
  {25,'x',1.9}
};

指针与结构体数组遍历

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <Windows.h>

//定义一个结构体。
struct Man{
    char name[20];
    int age;
};
void main(){
    //定义一个结构体数组。并且赋值。
    struct Man mans[] = { {"zhangsan",20}, {"lisi", 19} };
    //遍历结构体数组
    //1.
    struct Man *p = mans;
    for (; p < mans + 2; p++){
        printf("%s,%d\n", p->name, p->age);
    }

    //2.
    int i = 0;
    for (; i < sizeof(mans) / sizeof(struct Man); i++){
        printf("%s,%d\n", mans[i].name, mans[i].age);
    }

    //(*env)->

    system("pause");
}

结构体的大小（字节对齐）

结构体变量的大小，必须是最宽基本数据类型的整数倍。提升读取的效率

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <Windows.h>

struct Man{
    int age;
    double weight;  
};

void main(){

    struct Man m1 = {20,89.0};
    printf("%#x,%d\n", &m1,sizeof(m1));
    getchar();
}

结构体与动态内存分配

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <Windows.h>

struct Man{
    char *name;
    int age;
};

void main(){
    //初始化
    struct Man *m_p = (struct Man*)malloc(sizeof(struct Man) * 10);
    struct Man *p = m_p;
    //赋值
    p->name = "Jack";
    p->age = 20;
    p++;
    p->name = "Rose";
    p->age = 20;

    struct Man *loop_p = m_p;
    for (; loop_p < m_p + 2; loop_p++){
        printf("%s,%d\n", loop_p->name, loop_p->age);
    }

    free(m_p);
    getchar();
}

结构体函数指针成员

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <Windows.h>

struct Girl{
    char *name;
    int age;
    //函数指针
    void(*sayHi)(char*);
};
//Girl结构体类似于Java中的类，name和age类似于属性，sayHi类似于方法
void sayHi(char* text){
    MessageBoxA(0, text, "title", 0);
}

void main(){
    struct Girl g1;
    g1.name = "Lucy";
    g1.age = 18;
    g1.sayHi = sayHi;

    g1.sayHi("hello");

    getchar();
}

typedef struct Girl{
    char *name;
    int age;
    //函数指针
    void(*sayHi)(char*);
}Girl;

//Girl结构体指针取别名GirlP
typedef Girl* GirlP;

void sayHi(char* text){
    MessageBoxA(0, text, "title", 0);
}

//改名
void rename(GirlP gp1){
    gp1->name = "Lily";
}

void main(){
    Girl g1 = { "Lucy", 18, sayHi };
    GirlP gp1 = &g1;
    gp1->sayHi("Byebye!");
    //传递指针，改名
    rename(gp1);

    getchar();
}

---

联合体

联合所有成员引用的是内存中的相同位置。当你想在不同时刻把不同的东西存储于同一个位置时，就可以使用联合。

不同类型的变量共同占用一段内存（相互覆盖），联合变量任何时刻只有一个成员存在，节省内存
联合体变量的大小=最大的成员所占的字节数

例如：

union hold{
    int digit;
    double bigf1;
    char letter;
}

我们可以这么定义联合变量.

union hold fit; //hold类型的联合变量。
union hold save[10]; //10个联合变量的数组。
union hold *pu；指向联合变量的指针。

联合的初始化。

union hold valA；
valA.letter = 'R';
union hold valB = valA; //把一个联合初始化为另一个联合。
union hold valC = {88}; //初始化联合的digit成员。
union hold valD = {.bigf1 = 118.2} //z指定初始化项目。