11、const修饰的指针

const：只读。只允许被访问，不允许修改

表示该变量只允许使用，不允许被修改，记得初始化const int num=1

const int *p;    //同下

int const *p;    //修饰*p，*p的内容只读，*p=num ×，p=&num √

int *const p;    //修饰p，指针p只读，p=&num ×



const int *const p;    //同下

int const *const p;    //指针p只读，*p内容只读，记得初始化

12、void* 指针（万能指针）

void*：缺省类型的指针

char*，int*，short*...这些指针，不仅保存地址，还有具体指向，明确指向sizeof（基类型）个字节的空间

void *p：只是一个保存地址编号的变量

void*<-------->char*，int*，short*...

*（int *）p；

memcpy系统函数

#include<string.h>
memcpy(void *dst,const void *src,sizrof(a))
内存重叠问题

#include<stdio.h>
#include<string.h>
void *mymemcpy(void *dst,const void *src,int size)
{
    char *d=(char *)dst;
    char *s=(char *)src;
    int i=0;
    for(i=0;i<size;++i)
    {
        *(d+i)=*(s+i);
    }
    return dst;
}
void show_mymencpy(void *dst,int len)
{
    int i;
    char *d=(char *)dst;
    for(i=0;i<len;++i)
    {
        printf("%c ",d[i]);
    }
    printf("\n");
}
int main()
{
    
    char a1[100]={"hello"};
    char a2[100]={0};
   
    mymemcpy(a2,a1,sizeof(a1));
    //int len=strlen(a2);
    int len=sizeof(a2)/sizeof(a2[0]);
    show_mymencpy(a2,len);
}

构造数据类型

数据类型：short、int、long、char、float、double、void

指针类型

构造数据类型：结构体、共用体、枚举

1、结构体

1语法

struct  名字

{

        数据类型 成员1；

        数据类型 成员2；

        数据类型 成员3；

        ...

};

//声明了名为struct data的新的数据类型
struct  data
{
        int year;
        int mon;
        int day;
        struct time mytime;
};

注意

1、声明结构体时，{ }后的分号不可省略

2、结构体内，成员之间用分号隔开

3、struct后面的名称可以省略，匿名结构体

4、结构体放在全局作用域

2结构体变量定义

结构体类型  变量名；

struct  data   mydata；

struct 

{

        int year;

        int mon;

        int day;

}mydata;

声明结构体类型的同时，定义了变量mydata

3结构体初始化

//全部初始化
struct data mydata={2026，8，6}；
struct data mydatatime={{2026,8,6},{14,6}};

//部分初始化
struct data mydata1=
{
     .mon=8,
     .day=6
};

4结构体数据成员访问

• 通过结构体变量访问结构体成员

变量名.成员1；

变量名.成员2；

变量名.成员3；

printf("%d,%d,%d",
mydata.year,
mydata.mon,
mydata.day,
};

• 通过结构体指针访问结构体成员

结构体指针->成员1；

结构体指针->成员2；

结构体指针->成员3；

5结构体的存储方式

原则：

1.结构体成员在内存中存储时，成员必须存储在自己字节大小的整数倍位置

2.结构体整体占内存大小，一定是结构体中最大成员字节数的整数倍

注意：

1.在不同操作位系统下，相同结构体在内存中占用内存空间可能不一样。

64位系统，long类型和指针类型占8字节；而32位系统，long类型和指针类型占4字节

2.可以强制让结构体按指定字节数对齐

#pragma pack(1)//以下强制按1字节对齐

struct s
{}；

#pragma pack()//取消1字节对齐

6结构体做函数参数

两种传参方式：

如果要在被调函数中修改主调函数中的结构体变量，则传递结构体变量的地址

如果在被调函数中仅使用主调函数中定义的结构体变量，可以值传递，也可以地址传递

#include<stdio.h>
struct stu
{
    char name[32];
    int age;
    int score;
};

struct stu get_stu_info()
{
    struct stu s;
    scanf("%s",s.name);
    scanf("%d",&s.age);
    scanf("%d",&s.score);
    return s;
}

void get_stu_info_1(struct stu *s)
{
    scanf("%s",s->name);
    scanf("%d",&s->age);
    scanf("%d",&s->score);
}

int main()
{
    struct stu s;
    s=get_stu_info();
    printf("%s %d %d\n",s.name,s.age,s.score);

    get_stu_info_1(&s);
    printf("%s %d %d\n",s.name,s.age,s.score);
    return 0;
}

7.结构体数组

struct 名称 数组名[元素个数]；

struct stu array[3]={{"zhangsan",20,100},{"lisi",21,90},{"wanger",22,85}};

array[下标]；类型---》struct stu类型

结构体数组的三种访问方式
printf("%s %d %d\n",s[i].name,s[i].age,s[i].score);

printf("%s %d %d\n",(s+i)->name,(s+i)->age,(s+i)->score);

printf("%s %d %d\n",(*(s+i)).name,(*(s+i)).age,(*(s+i)).score);