C/C++(结构体)

结构体(struct)

从某种意义上说，会不会使用struct，如何使用struct是区别一个开发人员是否具备丰富开发经验的试金石。

处理由不同类型成员构成的构造类型，要采用结构体的方式。

定义：关键字struct.

无名结构体,一般用于定义类型相同时,定义变量;并且不会带来多余的命名。

struct{
    char name[40];
    int age;
    int num;
    float score;
}s1,s2,s3,s4;
int main() {
    struct{
        char name[40];
        int age;
        int num;
        float score;
    }s1;
    ....
    return 0;
}

有名结构体

一处定义各处使用

struct stu{
    char name[40];
    int age;
    int num;
    float score;
}
int main() {
    struct stu s1;
    struct stu s2;
    struct stu s3;
    return 0;
}

typedef

对现有类型取别名，不能创造新的类型(typerename)。

使用方法：

1.先用原类型定义变量

2.在定义前加上typedef

3.将原来的名字改成自己需要的类型名

typedef char        int8;
typedef short       int16;
typedef int         int32;
typedef long long   int64;
int main() {
    int8  i8;
    int16 i16;
    int32 i32;
    int64 i64;
    return 0;
}

别名结构体

typedef是一个常用于对结构体取别名的关键字，更好的用于结构体中

typedef struct{
    char name[40];
    int age;
    int num;
    float score;
}Stu;
int main() {
    Stu s1;
    Stu s2;
    Stu s3;
}

typedef与#define区别

typedef:构成c语言语句参与编译。

#define构成的语句在预处理阶段处理完毕

#fefine DINT int
int main() {
    DINT a,b,c;//所有声明时要替换。
}

int main() {
    char *p,q;
    printf("sizeof(p) = %d sizeof(q) = %d\n",sizeof(p),sizeof(q));//4,1
    typedef char * pChar;
    pChar a,b;
    printf("sizeof(a) = %d sizeof(b) = %d\n",sizeof(a),sizeof(b));//4,4

#define DpChar char *
    DpChar m,n;//<=>char * m,n;
    printf("sizeof(m) = %d sizeof(n) = %d\n",sizeof(m),sizeof(n));//4,1

    return 0;
}

struct的初始化

凡是基本类型，既可以在定义的时候初始化，也可以先定义再赋值。

凡是构造类型，要么在定义的时候初始化，不可以先定义再以实例化的方式赋值。

初始化是一种特殊的语法，跟赋值不等价。

成员赋值，不能已初始化的方式赋值（如数组，字符串等）

struct stu{
    char name[100];
    int num;
    char sex;
    float score;
}

int main() {
    struct stu s = {"assassin",10001,'f',99};
    //也可以这样赋值
    /*
    struct stu s;
    s.name = "assassin";//错误的,赋值不能这样写，和初始化有区别
    strcpy(s.name,"assassin");
    s.num = 1001;
    ...
    */
    return 0;
}

struct stu{
    char name[100];
    int num;
    char sex;
    float score;
}
int main() {
    struct stu s;
    scanf("%s%d %c%f\n",s.name,&s.num,&s.sex,&s.score);//其中s.name,name是个数组，数组时个特殊的指针，所以前面不用取址符。&的优先级低于"."的优先级。
    return 0;
}

struct的访问

一类是访问栈上的，一类是访问堆上的。（点乘员运算符，指向成员运算符）

#include<stdio.h>
#include<stdlib.h>
struct stu{
    char name[100];
    int num;
    char sex;
    float score;
};
int main() {
    struct stu s = {"assassin",10001,'f',99};
    struct stu *pa = &s;
    //点乘运算访问
    printf("name   = %s\n",(*pa).name);
    printf("num    = %d\n",(*pa).num);
    printf("sex    = %c\n",(*pa).sex);
    printf("score  = %f\n",(*pa).score);

    printf("======================\n");

    printf("name   = %s\n",s.name);
    printf("num    = %d\n",s.num);
    printf("sex    = %c\n",s.sex);
    printf("score  = %f\n",s.score);
    //足以说明*pa <=> s

//"."点乘优先级高于"*"解引用运算符
    printf("======================\n");
    //指向成员访问
    printf("name   = %s\n",pa->name);
    printf("num    = %d\n",pa->num);
    printf("sex    = %c\n",pa->sex);
    printf("score  = %f\n",pa->score);
    return 0;
}
/*
name   = assassin
num    = 10001
sex    = f
score  = 99.000000
======================
name   = assassin
num    = 10001
sex    = f
score  = 99.000000
======================
name   = assassin
num    = 10001
sex    = f
score  = 99.000000
*/

堆上的访问

typedef struct stu{
    char name[100];
    int num;
    char sex;
    float score;
}Stu;
int main() {
    Stu *pa = (Stu*)malloc(sizeof(Stu));
    strcpy(pa->name,"assassin");//赋值
    pa->num = 10001;
    pa->sex = 'f';
    pa->score = 99;

    printf("name   = %s\n",pa->name);
    printf("num    = %s\n",pa->num);
    printf("sex    = %s\n",pa->sex);
    printf("score  = %s\n",pa->score);

    free(pa);
    return 0;
}
/*
name   = assassin
num    = 10001
sex    = f
score  = 99.000000
*/

struct赋值

相同结构体类型的变量间，可以赋值。不同类型不可以。词语发基础奠定了可以用与传参和返值。

typedef struct stu{
    char name[100];
    int num;
    char sex;
    float score;
}Stu;
int main() {
    Stu s;
    Stu s2 = {"assassin",1003,'f',99};
    s = s2;
    printf("%s %d %c %f\n",s.num,s.num,s.sex,s.score);//是可以赋值的

    return 0;
}

结构体支持赋值，访问和数组一样

typedef struct _stu{
    char name[10];
}Stu;
typedef struct _array{
    int arr[10];
}Array;
int main() {
    int arr[10] = {1,2,23,4,5,6,78,};
    int arr2[10];
    arr2 = arr;//error
    Stu stu1 = {"assassin"};
    Stu stu2;
    stu2 = stu1;//正确

    Array arr3 = {1,2,23,4,5,6,7,8};
    Array arr4;
    arr4 = arr3;//和上面有区别
    for(int i = 0;i<10;i++) {
        printf("%d\n",arr4.arr[i]);
    }
}

传参和返回值的本质就是依次赋值

typedef struct _complex{
    float real;
    float image;
}MyComplex;
//实现一个函数，实现两个负数相加
MyComplex addComplex(MyComplex x,MyComplex y) {
    MyComplex t;
    t.real = x.real + y.real;
    t.image = x.image + y.image;
    return t;
}
int main() {
    MyComplex c1 = {1,2};
    MyComplex c2 = {3,4};
    MyComplex retc = addComplex(c1,c2);

    printf("(%.2f,%.2f)\n",retc.real,retc.image);

    return 0;
}
//(4.00,6.00)

C语言对于数组的处理就是指针，对于结构体也推荐传指针。（即使有很大的数据，只传4个字节，而且效率提高了很大）

typedef struct _complex{
    float real;
    float image;
}MyComplex;
//实现一个函数，实现两个负数相加
MyComplex addComplex(MyComplex *px,MyComplex *py) {
    MyComplex t;
    t.real = px->real + py->real;
    t.image = px->image + py->image;
    return t;
}
int main() {
    MyComplex c1 = {1,2};
    MyComplex c2 = {3,4};
    MyComplex retc = addComplex(&c1,&c2);

    printf("(%.2f,%.2f)\n",retc.real,retc.image);

    return 0;
}
//效率大大提高

结构体数组

结构体数组的本质：是一维数组，只不过是一维数组中的每一个个成员又是结构体。

typedef struct _stu{
    int num;
    char name[100];
    char sex;
    float score;
}Stu;
int main() {
    Stu s[] = {{1001,"assassin",'f',99},{1002,"Wunworld",'f',89},{1003,"seafwg"},{1004,"intelwisd"}};
    for(int i = 0;i < sizeof(s)/sizeof(*s);i++) {
        printf("num    = %d\n",s[i].num);
        printf("name   = %s\n",s[i].nam);
        printf("sex    = %c\n",s[i].sex);
        printf("score  = %f\n",s[i].score);
    }
}

实例投票：现有三位侯选人员，侯选人包含名字和选票数两项，现在 10 人对其投票，每个人限投票一次，投票完毕，打印投票结果，如有名字打错，算作弃权处理。

typedef struct _candidate{
    char name[30];
    int voteCount;
}Candidate;
void disCandidate(Candidate *c,int n,int m);
int main() {
    //初始化候选人
    Candidate can[3] = {
        {"assassin",0},
        {"wunworld",0},
        {"seafwg",0}
    };
    int count = 0;
    char buf[1024];
    //是个人选举
    for(int i = 0;i < 10;i++) {
        printf("请你选举自己心中的候选人");
        scanf("%s",buf);
        int flag = 1;
        for(int j = 0;j < 3;j++) {
            if(!strcmp(buf,can[j].name)) {
                can[j].voteCount++;
                flag = 0;
            }
        }
        if(flag != 0) {
            count++;
        }
    }
    disCandidate(can,3,count);
}
//显示选举后的选票人
void disCandidate(Candidate *c,int n,int count) {
    for(int i = 0;i < n;i++) {
        printf("Name:10%s VoteCount:%2d\n",c[i].name,c[i].voteCount);
    }
    printf("the give up people: %d\n",count);
    //进行排序
    int idx = 0;
    for(int i = 0;i < n;i++) {
        if(c[i].voteCount > c[idx].voteCount) {
            idx = i;
        }
    }
    printf("恭喜%s获得了选举！\n",c[idx].name);
}

结构体的嵌套

struct _birth {
    int year;
    int month;
    int day;
};

typedef struct _stu {
    char name[20];
    int num;
    char sex;
    float score;
    struct _birth birth;
    //<=>
    /*struct _birth {
        int year;
        int month;
        int day;
    }birth;*/
}Stu;
int main() {
    Stu s = {"assassin",10001,'f',99,{1992,04,15}};
    printf("name  = %s\n",s.name);
    printf("year  = %d\n",s.birth.year);
    printf("month  = %d\n",s.birth.month);
    printf("day    = %d\n",s.birth.day);
}
/*
name  = assassin
year  = 1992
month  = 4
day    = 15
*/

结构体类型的大小

类型本身不占空间，类型产生的变量才占空间

结构体中的每个成员的地址均是可以获得的。

typedef struct _staff{
    char sex;
    int age;
}Staff;

int main() {
    Satff s;
    printf("sizeof(Staff) = %d\n",sizeof(Staff));
    printf("sizeof(s)     = %d\n",sizeof(s));

    printf("&s        = %p\n",&s);
    printf("&s.sex    = %p\n",&s.sex);
    printf("&s.age    = %p\n",&s.age);

    return 0;
}
/*
sizeof(Staff) = 8
sizeof(s)     = 8
&s        = 0061FEA8
&s.sex    = 0061FEA8
&s.age    = 0061FEAC
*/

typedef struct _staff{
    char sex;
    int age;
    short like;
}Staff;

int main() {
    Staff s;
    printf("sizeof(Staff) = %d\n",sizeof(Staff));
    printf("sizeof(s)     = %d\n",sizeof(s));

    printf("&s        = %p\n",&s);
    printf("&s.sex    = %p\n",&s.sex);
    printf("&s.age    = %p\n",&s.age);
    printf("&s.like   = %p\n",&s.like);

    return 0;
}
/*
sizeof(Staff) = 12
sizeof(s)     = 12
&s        = 0061FEA4
&s.sex    = 0061FEA4
&s.age    = 0061FEA8
&s.like   = 0061FEAC
*/

为什么结构体里面的char,short是4个字节

sex后面空了三个字节，然后去填age,like后面空了两个字节，sex与age直接空了三个字节。like应该填到那个位置。

内存对齐

一个成员变量需要多少个机器周期去读的现象，称为内存不对齐。x实现内存对齐主要原因是牺牲空间换取时间的方法。

对齐规则

x86linux默认#pragma(4),window默认#pragma pack(8)。linux最大支持4字节对齐。

方法：

1.取pack(n)的值(n=1 2 4 8--),去结构体中类型最大值m，两者取小即为外对齐 大小Y=(m<n?m:n);

2.将每一个结构体的成员大小与Y比较取较小者为X作为内对其的大小。

3.所谓按X对齐，即为地址(设起始地址为0)能被X整除的地方开始存放数据。

4.外部对其原则是依据Y的值(Y的最小整数倍)，进行补空操作。

例如：以上述为例

typedef struct _staff{
    char sex;
    short num;
    int age;
}Stu;

1.外对齐：pack(8)默认为8 n=8,则按照1，m=4,即Y=4,----外对齐。(sex与age直接空了三个字节)
2.内对齐：上述Y=4,与成员大小1,2,4比较取小值（x=1,2,4）---内对齐
3.按照X对齐：
0-1 2-4 4-8-----8(外侧是Y的最小整数倍补齐)
    例如:成员大小1,4,2比较后(X=1,4,2)则：
    0-1 4-8 8-10(10不是Y的最小整数倍取12)---大小为12
    eg:pack(1), n=1,m=4,Y=1,
    成员：1 4 2，则X=1 1 1,
    外对齐：0-1 1-5 5-7(7是1的倍数)---大小为7

eg:

#pragma pack(4)
typedef struct _stu{
    char sex;
    double num;
    int age;
}Stu;
int main() {
    printf("sizeof(Stu) = %d\n",sizeof(Stu));
}
/*
sizeof(Stu) = 16
sizeof(s) = 16
*/
/*pack(4),n=4,m=8--->Y=4
成员：1 8 4与Y比较取小者X=1 4 4
0-1 4(能与X整除放成员个大小)-12 12-16-----大小为16
*/

结构体注意事项

typedef struct _stu{
    char name[20];
    int score;
}Stu;
int main() {
    Stu s;
    strcpy(s.name,"bob");
    s,score = 99;
}

typedef struct _stu{
    char *name;
    int score;
}Stu;//只有8个字节，name未初始化
int main() {
    Stu s;
    strcpy(s.name,"bob");//Error 会挂机
    s.name = (char*)malloc(100);//解决办法放在堆上
    strcpy(s.name,"jim");
    printf("name = %s score = %d\n",s.name,s.score);
    free(s.name);//必须要释放
    s.score = 99;
}

申请空间的时候从外至内，释放空间的时候从内之外。

typedef struct _stu{
    char *name;
    int score;
}Stu;//只有8个字节，name未初始化
int main() {
    Stu *ps = (Stu *)malloc(sizeof(Stu));//ps实在栈上申请了8，结构体在堆上，没有初始化。并没有指向。解决办法，再次申请一个堆空间存放地址
    ps->name = (char*)malloc(100);
    strcpy(ps->name,"assassin");
    ps->score = 200;
    printf("name = %s score = %d\n",ps->name,ps->score);
    free(ps->name);//
    free(ps);
    return 0;
}

数据类型：内存是以字节为单位进行线性编址的硬件基础，对内存进行格式化。