内存操作函数
memcpy
void* memcpy (void* destination , const void* source , size_t num)
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
- 这个函数在遇到 ‘\0’ 的时候并不会停下来，按照字节一个一个的拷贝过去。
- 如果source和destination有任何的重叠，复制结果都是未定义的
- 返回值支持连续拷贝memcpy (a , ( memcpy ( b , c , 10 ) , 10 )
- memcpy的模拟实现
#include<stdio.h>
void* my_memcpy(void* dst, const void* src, size_t num)
{
char* ch_dst = (char*)dst;
char* ch_src = (char*)src;
for (int i = 0; i < num; ++i)
{
ch_dst[i] = ch_src[i];
}
return dst;
}
int main()
{
char a[] = "abcdefghijk ";
char b[11];
my_memcpy(b, a, 11);
for (int i = 0; i < 11; ++i)
{
printf("%c", b[i]);
}
return 0;
}
memove
void* memove( void* destination , const void* source , size_t num)
- 和memcpy的差别就是memove函数处理的原内存块和目标内存块是可以重叠的。
- 如果原空间和目标空间出现重叠，就得使用memove函数处理。
- 这里的重叠会出现两种情况前重叠和后重叠
- memove的模拟实现
#include<stdio.h>
void* my_memmove(void* dst, const void* src, size_t num)
{
char* ch_dst = (char*) dst;
const char* ch_src = (const char*)src;
if (ch_dst >= ch_src&&ch_dst <= ch_src + num)
{
for (int i = num-1; i >=0; --i)
ch_dst[i] = ch_src[i];
}
if (ch_dst +num>= ch_src&&ch_dst+num <= ch_src + num)
{
for (int i = 0; i < num; ++i)
ch_dst[i] = ch_src[i];
}
return dst;
}
int main()
{
int a3[9] = {
1, 2, 3, 4, 5 };//这里的数组空间一定要满足拷贝后所需要空间大小
my_memmove(a3 + 4, a3, 20);
return 0;
}
memset
void* memset(viod* ptr，int value , size_t num);
- 将每一个字节初始化
- 但是存在局限性
#include<stdio.h>
#include<string.h>
int main()
{
int a[10];
memset(a, 0, sizeof(a));//将每一个字节初始化为0
//存在局限性，防止误用
memset(a, 1, sizeof(a));
//这样初始化就是将整型的每一个字节初始化为1，就变成了00000001 00000001 00000001 00000001（16843009）
return 0;
}
结构体
结构体类型的声明
- 结构是一些值的集合，这些值称为成员变量。结构的每一个成员可以是不同类型的变量
- 结构体在声明时没有开空间，定义之后才会开空间
- 访问结构体成员时可以使用 -> 或 .
- 例如描述一个学生时
struct Stu
{
char name[20];
int age;
char sex[5];
char id[20];
};
- 在声明的时候，可以不完全声明，结构体在声明的时候可以省略掉结构体标签，比如：
//匿名结构体类型
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20],*p;//结构体变量，这里的变量是全局变量，但是并不推荐这样写。
typedef struct Teacher
{
// 结构体的成员
char name[30];
int age;
char addr[100];
int tel;
}Tea, T, *PT;
//Tea,T是typedef出来的struct Teacher 类型；*PT是typedef出来的指针
//等价于typedef struct Teacher Tea;
//等价于typedef struct Teacher* Pt;
注意：编译器会把以上两个结构体当成完全不同的两个类型，所以p=&x是非法的。
结构体的自引用
- 在结构体中可以包含一个类型为该结构本身的成员
struct Node
{
int val;
struct Node next;//这里是非法定义，这样会存在无数多个结构体
}
struct Node
{
int val;
struct Node* next;//应该定义为指针形式
}
结构体的定义和初始化
有了结构体类型，就可以定义变量
struct Point
{
int x;
int y;
}p1;//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2
struct Point p3={
x,y};//初始化：定义变量的同时赋初值
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
}；
struct Stu s={
"zhangsan",20};//初始化
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1={
10,{
4,5},NULL};//结构体嵌套初始化
struct Node n2={
20,{
5,6},NULL};//结构体嵌套初始化
结构体内存对齐
首先我们需要掌握结构体对齐规则：
-
第一个成员与结构体变量偏移量为0的地址处。
-
其他成员变量要对齐到某个数字（对其数）的整数倍的地址处。
对其数 = 编译器默认的一个对其数 与 该成员大小的较小值。 -
vs中默认的值为8
-
结构体总大小为最大对其数（每个成员变量都有一个对其数）的整数倍。
-
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对其数的整数倍，结构体的整体大小就是所有最大对其数（含嵌套结构体的对其数）的整数倍。
那么为什么存在内存对齐呢？
- 平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
- 性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要做两次内存访问；而对齐的内存访问仅需要一次访问。
总体来说：
结构体的内存对齐是拿空间换取时间的做法。
那么在设计结构体的时候，既要满足对齐，又要节省空间，那么我们就要占用空间小的成员尽量集中在一起。下面有两个例子：
struct s1
{
char c1;
int i;
char c2;//所占内存为12个字节
};
struct s2
{
char c1;
char c2;
int i;//所占内存为8个字节
};
虽然s2于s1类型的成员一模一样，但是他们所占空间的大小有一些区别
修改默认对齐数
#include<stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct s1
{
char c1;//1个字节（占位0）
int i;//4个字节（占位4，5，6，7）
char c2;//一个字节（占位8）
//所以所占空间为9个字节，但是结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
};
#pragma pack()//取消设置的默认对其数，还原为默认
int main()
{
printf("%d\n",sizeof(struct s1));//输出结果为12
return 0;
}
对齐方式不合适的时候，我们可以自己更改默认对其数
结构体传参
函数传参的时候，参数需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
所以，结构体传参的时候，要传结构体的地址。
struct S
{
int data[1000];
int num;
};
struct S s={
{
1,2,3,4},1000};
void print1(struct S*ps)
{
printf("%d\n",ps->num);
}
int main()
{
print1(&s);
return 0;
}
位段
位段的声明和结构体是类似的，但是存在两个不同：
- 位段成员必须是int、unsigned int 或 signed int 。
- 位段的成员名后边有一个冒号和一个数字。比如：
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};//这里的A就是一个位段
那么位段A的大小是多少呢？
位段的内存分配
- 位段的成员可以是int unsigned int signed int 或是 char (属于整型家族)类型
- 位段的空间上是按照需要以4个字节( int )或者1个字节（char）的方式来开辟的。
- 位段涉及很多不确定的因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
- 下面举例说明
位段的跨平台问题
- int位段被当成有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。(16位机器最大16,32位机器最大32，写成27，在16位机器会出问题。
- 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
- 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确的。
总结
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。