C++复习day02

一、库函数的模拟实现

1.memcpy的使用和模拟

首先先来了解一下memcpy函数的作用是什么？

void * memcpy ( void * destination, const void * source, size_t num );

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的
  先举一个没有重叠的例子：

#include <iostream>
#include <cstring>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8 ,9,10 };
	int arr2[20]{};
	memcpy(arr2, arr1, sizeof arr1);
	for (int i = 0; i < 20; ++i)
		std::cout << arr2[i] << ' ';
	//1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0
	return 0;
}

再举一个重叠的例子：

#include <iostream>
#include <cstring>

int main()
{
	int arr[20] = { 1,2,3,4,5,6,7,8 ,9,10 };
	memcpy(arr + sizeof(int), arr, sizeof(int)* 10);
	for (int i = 0; i < 20; ++i)
		std::cout << arr[i] << ' ';
	//1 2 3 4 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0
	return 0;
}

很明显，这种结果并不是我们想要的结果，所以memcpy看来不适合用于有重叠的拷贝。有重叠的拷贝就应该使用memmove来操作
下面来模拟一下memcpy函数

#include <iostream>
#include <cstring>
#include <assert.h>

void* my_memcpy(void* dst, void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);
	for (size_t i = 0; i < count; ++i)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, sizeof arr1);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	//1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0
	return 0;
}

2.memmove的使用和模拟

void * memmove ( void * destination, const void * source, size_t num );

• 和memcpy的差别就是memmove函数处理的源内存块和⽬标内存块是可以重叠的
• 如果源空间和⽬标空间出现重叠，就得使⽤memmove函数处理。
  memmove的使用：

#include <iostream>
#include <cstring>
#include <assert.h>

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr + 2, arr, sizeof(int) * 3);
	for (int i = 0; i < 10; ++i)
		std::cout << arr[i] << ' ';
	//1 2 1 2 3 6 7 8 9 10
	return 0;
}

memmove的实现
很明显倒叙拷贝就可以了，下面给出代码：

#include <iostream>
#include <cstring>
#include <assert.h>
void* my_memmove(void* dst, void* src, size_t count)
{
	void* ret = dst;
	//判空
	assert(dst);
	assert(src);

	if (dst < src)
	{
		//直接正序拷贝就可以了
		for (size_t i = 0; i < count; ++i)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else {
		//需要倒叙拷贝
		//求出结束的位置
		void* ddst = (char*)dst + count;
		void* ssrc = (char*)src + count;
		for (size_t i = 0; i < count; ++i)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	return ret;
}
void test1()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr + 1, arr + 2, sizeof(int) * 5);
	for (int i = 0; i < 10; ++i)
		std::cout << arr[i] << ' ';
}
void test2()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr + 1, arr + 2, sizeof(int) * 5);
	for (int i = 0; i < 10; ++i)
		std::cout << arr[i] << ' ';
}

int main()
{
	test1();
	//1 3 4 5 6 7 7 8 9 10
	std::cout << std::endl;
	test2();
	//1 3 4 5 6 7 7 8 9 10
	return 0;
}

3.strstr的使用和模拟

char *strstr( const char *string, const char *strCharSet );

来演示一下strstr的用法

#include <iostream>
#include <cstring>
#include <assert.h>

int main()
{
	const char* s = "hello world";
	std::cout << strstr(s, "world") << std::endl;
	//world
	return 0;
}

下面来实现一下strstr函数

这里的strstr暂时不用kmp算法实现，等到回头复习算法的时候会再来写这个strstr的kmp实现方式

#include <iostream>
#include <cstring>
#include <assert.h>
#include <cstdio>

char* my_strstr(const char*s1, const char*s2) //非kmp算法
{
	//s1是被查找的字符串，s2是要查找的字符串
	assert(s1 && s2);
	size_t len = strlen(s1);
	size_t j = 0;
	for (size_t i = 0; i < len; ++i)
	{
		if (s1[i] == s2[j])
		{
			size_t ii = i;
			while (s2[j] && s1[ii] == s2[j])
			{
				++j, ++ii;
			}
			if (s2[j] == '\0')return (char*)(s1 + i);
			else
				j = 0;
		}
	}
	return NULL;
}
int main()
{
	char s1[20], s2[20];
	gets_s(s1);
	gets_s(s2);
	char* result = my_strstr(s1, s2);
	if (result)
	{
		std::cout << result << std::endl;
	}
	else {
		std::cout << "NULL" << std::endl;
	}
	//world
	return 0;
}

4.strlen，strcpy（较为简单，考察的不多）

size_t strlen( const char *string );
char *strcpy( char *strDestination, const char *strSource );

#include <iostream>
#include <cstring>
#include <assert.h>
#include <cstdio>

size_t my_strlen(const char* s)
{
	const char* cur = s;
	while (*cur)
		cur++;
	return cur - s;
}
int main()
{
	std::cout << my_strlen("hello") << std::endl;
	//world
	return 0;
}

#include <iostream>
#include <cstring>
#include <assert.h>
#include <cstdio>

char* my_strcpy(char* dst, const char* src)
{
	char* start = dst;
	while (*dst)
		dst++;
	size_t i = 0;
	while (dst[i] = src[i])++i;
	return start;
}
int main()
{
	char s1[20] = "hello ";
	char s2[10] = "world";
	my_strcpy(s1, s2);
	std::cout << s1 << std::endl;
	return 0;
}

二、自定义类型

1.结构体内存对齐

结构体就是一些值的集合
直接上重点，来介绍一下内存对齐
内存对齐的对齐规则：

1. 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
2.  其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
    **对齐数** = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。
    - VS 中默认的值为 8
    -  Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩
3. 结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的
整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构
体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

//练习
//练习1
struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%d\n", sizeof(struct S1));

//练习2
struct S2
{
 char c1;
 char c2;
 int i;
};
printf("%d\n", sizeof(struct S2));

//练习3
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));

//练习4-结构体嵌套问题
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%d\n", sizeof(struct S4));

2.联合体（共用体）

像结构体⼀样，联合体也是由⼀个或者多个成员构成，这些成员可以不同的类型。
但是编译器只为最⼤的成员分配⾜够的内存空间。联合体的特点是所有成员共⽤同⼀块内存空间。所
以联合体也叫：共⽤体。
给联合体其中⼀个成员赋值，其他成员的值也跟着变化。

#include <stdio.h>

union Un
{
	char c;
	int i;
};
int main()
{
	union Un u = { 0 };
	u.c = 'a';
	printf("%d\n", u.i); // 97
	printf("%d\n", sizeof u); //4
	return 0;
}