[c/c++] programming之路（26）、结构体

一、初始化字符串

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

struct stu {
    char name[];
    int age;
};

void main() {
    struct stu s1;//C版本
    stu s2 ;//C++版本
    //s2.name = "safdg";    字符串不可以用赋值号赋值
    //初始化字符串，两种方式：1.sprintf（stdio）；2.strcpy（string）
    sprintf(s2.name, "yincheng");
    strcpy(s1.name, "zhangxin");
    printf("%s\n", s1.name);
    getchar();
}

#include<stdio.h>
#include<stdlib.h>

struct ours {
    int num;
    char str[];//str是指针常量
};

void main() {
    struct ours o1 = { ,"hello china" };
    struct ours o2 = o1;//结构体直接赋值的时候，即使是字符串也可以赋值
    //o2.str = o1.str;//字符串不能直接赋值

    //字符串拷贝的方式
    sprintf(o2.str, o1.str);
    strcpy(o1.str, o2.str);

    printf("%d,%s\n", o2.num,o2.str);

    system("pause");
}

结构体内再定义结构体

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

struct china {
    int data;
    char name[];
    struct beijing {//结构体内部再定义结构体，但是没有创建结构体的实例
                    //再次定义的结构体内部的变量，会被当做母结构体的成员变量
        char str[];
        int num;
    };
};

void main() {
    struct china t1;
    t1.data = ;
    t1.num = ;
    //t1.beijing;    报错，不能这样使用
    sprintf(t1.name, "goA");
    sprintf(t1.str, "goB");
    printf("%d,%d,%s,%s\n",t1.data,t1.num,t1.name,t1.str);

    system("pause");
}

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

struct china {
    int data;
    char name[];
    struct beijing {//结构体内部再次定义结构体，创建结构体变量，该变量会直接作为一个成员
        char str[];
        int num;
    }b1;//内部定义的第一种方式
    struct beijing b2;//内部定义的第二种方式
};

void main() {
    struct china t2;
    t2.b1.num = ;//结构体嵌套用多个点访问
    sprintf(t2.b1.str, "ABC");
    printf("%d,%s\n",t2.b1.num,t2.b1.str);

    t2.b2.num = ;
    sprintf(t2.b2.str, "B2_ABC");
    printf("%d,%s\n", t2.b2.num, t2.b2.str);

    system("pause");
}

定义并初始化结构体数组

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

struct data{
    int num;
    float f1;
    char str[];
}db[] = { {,1.0,"1.0"},{ ,2.0,"2.0" },{ ,3.0,"3.0" }};

//结构体数组在内存里面是挨个挨个排列的

void main() {
    printf("%d\n", sizeof(struct data));
    printf("%x\n", db);//打印第一个元素地址
    printf("%x\n", &db[]);//打印三个元素地址
    printf("%x\n", &db[]);
    printf("%x\n",&db[]);
    system("pause");
}

结构体数组引用

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

struct dangdang{
    char email[];
    char name[];
    char addr[];
    int num;
    int bignum;
    char tel[];
    char phone[];
    double RMB;
}dbdd[]={{"asd@qq.com","顾士夫","上海市信息村",,,"","",12.3},
    {"zxc@qq.com","水电费","绵阳市程序村",,,"","",12.3},
    {"weq@qq.com","请问","北京市中心村",,,"","",12.3},
    {"hjjkhk@qq.com","预约单","复古风市给的村",,,"","",12.3},
};

void main() {
    char str[];
    scanf("%s",str);
    printf("你要查找的是%s    \n",str);
    int num=sizeof(dbdd)/sizeof(struct dangdang);//求出数组大小
    for (int i = ; i < num; i++)
    {
        if(strcmp(str,dbdd[i].phone)==){
            printf("找到了，邮件为%s，姓名为%s，地址为%s    \n",dbdd[i].email,dbdd[i].name,dbdd[i].addr);
        }
    }
    system("pause");
} 

二、指向结构体的指针

指针与结构体

#include<stdio.h>
#include<stdlib.h>

struct mydata{
    int num;
    char str[];
};

void main() {
    struct mydata md;//实例化结构体
    md.num=;
    sprintf(md.str,"gogogo");
    printf("%d,%s\n",md.num,md.str);

    struct mydata *p;//p存储地址，struct mydata决定了大小以及如何解析
    printf("%d\n",sizeof(p));//指针有几个字节
    p=&md;//结构体指针初始化，存储地址

    //修改指针指向的数据
    (*p).num=;
    sprintf(p->str,"wangwangwang");
    printf("%d,%s\n",(*p).num,(*p).str);
    printf("%d,%s\n",p->num,p->str);

    //指针访问结构体的两种方式：    (*p)    p->
    system("pause");
}

指向结构体数组的指针

#include<stdio.h>
#include<stdlib.h>

struct dangdang{
    char email[];
    char name[];
    char addr[];
    int num;
    int bignum;
    char tel[];
    char phone[];
    double RMB;
}dbdd[]={{"asd@qq.com","顾士夫","上海市信息村",,,"","",12.3},
    {"zxc@qq.com","姚远超","绵阳市程序村",,,"","",12.3},
    {"weq@qq.com","王明","北京市中心村",,,"","",12.3},
    {"hjjkhk@qq.com","崔帅帅","杭电",,,"","",12.3},
};

void main0() {
    int a[]={,,,,};
    for (int *p = a; p < a+; p++)//p++根据类型自增，此处一次增加四个字节，轮询内存地址
    {
        printf("%d,%x\n",*p,p);
    }
    system("pause");
}

void main(){
    for (struct dangdang *p = dbdd;p < dbdd+; p++)
    {
        printf("name=%s,addr=%s,phone=%s\n",p->name,(*p).addr,(*p).phone);
    }
    system("pause");
}

用指向结构体的指针作函数参数

#include<stdio.h>
#include<stdlib.h>

struct dangdang{
    char name[];
    int num;
};

void change(int num){//值传递：新建一个变量接受实际参数的值
    num=;
}
void changeA(struct dangdang ddt){//依旧是值传递：使用结构体作为参数，浪费内存，需要新建一个变量
    ddt.num=;
    printf("changeA=%x,%x\n",&ddt,&ddt.num);
}

void main(){
    struct dangdang ddt;
    printf("main=%x,%x\n",&ddt,&ddt.num);
    ddt.num=;
    sprintf(ddt.name,"ABCD");
    //change(ddt.num);
    changeA(ddt);

    printf("%d\n",ddt.num);
    system("pause");
}

void changeB(struct dangdang *p){//地址传递
    (*p).num=;
}

//change(ddt.num);　　changeA(ddt);

changeB(&ddt);

#include<stdio.h>
#include<stdlib.h>

struct dangdang{
    char name[];
    int num;
};

void datatest(struct dangdang ddd[]){//对于数组来说，参数传递的是地址
    printf("datatest=%d\n",sizeof(ddd)); //地址占四个字节
    struct dangdang dd[];//数组
    printf("datatest dd=%d\n",sizeof(dd));
}

void main(){
    struct dangdang ddd[];
    struct dangdang *p=ddd;
    printf("main=%d\n",sizeof(ddd));
    datatest(ddd);
    system("pause");
}

#include<stdio.h>
#include<stdlib.h>

struct dangdang{
    char name[];
    int num;
};

void dtc(struct dangdang ddd[]){
    ddd[].num=;
    sprintf(ddd[].name,"");
}

void main(){
    struct dangdang ddd[];
    ddd[].num=;
    sprintf(ddd[].name,"ABCD");

    struct dangdang *p=ddd;
    dtc(p);
    printf("%d,%s\n",ddd[].num,ddd[].name);
    system("pause");
}

内存动态分配

　　 //struct dangdang dd[1024*1024*1024];//直接报错，error：数组太大
    //struct dangdang dd[1024*1024];//运行报错
    //处理大数据，必须在堆里
    struct dangdang *p=(struct dangdang *)malloc(sizeof(struct dangdang)***);

#include<stdio.h>
#include<stdlib.h>

struct dangdang{
    char email[];
    char name[];
    char addr[];
    int num;
    int bignum;
    char tel[];
    char phone[];
    double RMB;
};

//动态分配内存，分配一个元素
void main0(){
    //处理大数据，必须在堆里
    struct dangdang *p=(struct dangdang *)malloc(sizeof(struct dangdang));
    sprintf(p->email,"yincheng@qq.com");
    sprintf(p->name,"yincheng");
    sprintf(p->addr,"清华大学");
    p->num=;
    p->bignum=;
    sprintf(p->tel,"");
    sprintf(p->phone,"");
    p->RMB=45.67;
    printf("%s,%s,%s,%d,%d,%s,%s,%f\n",p->email,p->name,p->addr,p->num,p->bignum,p->tel,p->phone,p->RMB);
    system("pause");
}

//动态分配内存，分配N个元素
int Size=;
void main(){
    struct dangdang *p=(struct dangdang *)malloc(sizeof(struct dangdang)*Size);

    //数组访问方式
    for (int i = ; i < Size; i++)
    {
        //写数据
        sprintf(p[i].email,"yincheng@qq.com");
        sprintf(p[i].addr,"清华大学");
        p[i].num=;
        //读数据
        printf("%s,%s,%d\n",p->email,p->addr,p->num);
    }
    printf("------------------------\n");

    //指针访问方式
    for (int i = ; i < Size; i++)
    {
        //p[i]等价于一个结构体    p[i]=(*(p+i)),后者多加一个括号是避免优先级的歧义
        sprintf((*(p+i)).email,"yincheng@qq.com");
        sprintf((*(p+i)).addr,"清华大学");
        (*(p+i)).num=;
        printf("%s,%s,%d\n",(*(p+i)).email,(*(p+i)).addr,(*(p+i)).num);
    }
    printf("------------------------\n");

    //指针轮询方式
    for (struct dangdang *px=p; px < p+Size; px++)
    {
        sprintf(px->email,"yincheng@qq.com");
        sprintf(px->addr,"清华大学");
        px->num=;
        printf("%s,%s,%d\n",px->email,px->addr,px->num);
    }

    system("pause");
}