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

一、初始化字符串

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

struct stu {
    char name[20];
    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
", s1.name);
    getchar();
}

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

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

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

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

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

    system("pause");
}

结构体内再定义结构体

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

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

void main() {
    struct china t1;
    t1.data = 100;
    t1.num = 99;
    //t1.beijing;    报错，不能这样使用
    sprintf(t1.name, "goA");
    sprintf(t1.str, "goB");
    printf("%d,%d,%s,%s
",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[100];
    struct beijing {//结构体内部再次定义结构体，创建结构体变量，该变量会直接作为一个成员
        char str[100];
        int num;
    }b1;//内部定义的第一种方式
    struct beijing b2;//内部定义的第二种方式
};

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

    t2.b2.num = 100;
    sprintf(t2.b2.str, "B2_ABC");
    printf("%d,%s
", 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[4];
}db[3] = { {1,1.0,"1.0"},{ 2,2.0,"2.0" },{ 3,3.0,"3.0" }};

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

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

结构体数组引用

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

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

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

 二、指向结构体的指针

指针与结构体

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

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

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

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

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

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

指向结构体数组的指针

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

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

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

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

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

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

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

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

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

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

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

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

changeB(&ddt);

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

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

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

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

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

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

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

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

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

内存动态分配

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

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

struct dangdang{
    char email[30];
    char name[30];
    char addr[100];
    int num;
    int bignum;
    char tel[30];
    char phone[30];
    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=100;
    p->bignum=1000;
    sprintf(p->tel,"0108848");
    sprintf(p->phone,"12345678911");
    p->RMB=45.67;
    printf("%s,%s,%s,%d,%d,%s,%s,%f
",p->email,p->name,p->addr,p->num,p->bignum,p->tel,p->phone,p->RMB);
    system("pause");
}

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

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

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

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

    system("pause");
}