C语言从入门到精通——字符串和内存

求非空字符串元素个数：

“ni chou sha chou ni za di”

字符串逆置： str_inverse

hello -- olleh

void str_inserse(char *str)
{
char *start = str; // 记录首元素地址
char *end = str + strlen(str) - 1; // 记录最后一个元素地址。

while (start < end)			// 首元素地址是否 < 最后一个元素地址
{
	char tmp = *start;		// 三杯水 char 元素交换
	*start = *end;
	*end = tmp;
	start++;			// 首元素对应指针后移
	end--;				// 尾元素对应指针前移
}

}

判断字符串是回文：

int str_abcbb(char *str)
{
char *start = str; // 记录首元素地址
char *end = str + strlen(str) - 1; // 记录最后一个元素地址。

while (start < end)			// 首元素地址是否 < 最后一个元素地址
{
	if (*start != *end)		// 判断字符是否一致。
	{
		return 0; 		// 0 表示非 回文
	}
	start++;
	end--;
}
return 1;				// 1 表示 回文

}

字符串处理函数： #include

字符串拷贝：

	strcpy:

		将 src 的内容，拷贝给 dest。 返回 dest。 保证dest空间足够大。【不安全】

		char *strcpy(char *dest, const char *src);

		函数调用结束 返回值和 dest参数结果一致。

	strncpy:

		将 src 的内容，拷贝给 dest。只拷贝 n 个字节。 通常 n 与dest对应的空间一致。

		默认 不添加 ‘\0’

		char *strncpy(char *dest, const char *src, size_t n);

		特性： n > src: 只拷贝 src 的大小

		       n < src: 只拷贝 n 字节大小。 不添加 ‘\0’

字符串拼接：

	strcat:

		将 src 的内容，拼接到 dest 后。 返回拼接后的字符串。	保证 dest 空间足够大。

		char *strcat(char *dest, const char *src);

	strncat：

		将 src 的前 n 个字符，拼接到 dest 后。 形成一个新的字符串。保证 dest 空间足够大。

		char *strncat(char *dest, const char *src, size_t n);

		函数调用结束 返回值和 dest 参数结果一致。


字符串比较：	不能使用 > < >= <= == !=

	strcmp:

		比较s1和s2两个字符串，如果相等 返回0.如果不相等，进一步表 s1 和 s2 对应位 ASCII码值。

		s1 > s2 返回1

		s1 < s2 返回-1

		int strcmp(const char *s1, const char *s2);

	strncmp:

		int strncmp(const char *s1, const char *s2, size_t n);

		比较s1和s2两个字符串的前n个字符，

		如果相等 返回0。如果不相等，进一步表 s1 和 s2 对应位 ASCII码值。（不比字符串ASCII码的和）

		s1 > s2 返回1

		s1 < s2 返回-1



字符串格式化输入、输出：

	sprintf():  s -- string

		int sprintf(char *str, const char *format, ...);

		对应printf，将原来写到屏幕的“格式化字符串”，写到 参数1 str中。

		printf("%d+%d=%d\n", 10, 24, 10+24);

		---》
		char str[100];

		sprintf(str, "%d+%d=%d\n", 10, 24, 10+24);  格式串写入str数组中。

	sscanf():

		int sscanf(const char *str, const char *format, ...);

		对应scanf， 将原来从屏幕获取的“格式化字符串”， 从 参数1 str中 获取。

		scanf("%d+%d=%d", &a, &b, &c);

		---》

		char str[]= "10+24=45";

		sscanf(str, "%d+%d=%d", &a, &b, &c);  a --> 10, b --> 24, c --> 45


字符串查找字符、子串：

	strchr():

		在字符串str中 找一个字符出现的位置。 返回字符在字符串中的地址。

		char *strchr(const char *s, int c);

		printf("%s\n" strchr("hehehahahoho", 'a'));  --> "ahahoho"

	strrchr():

		自右向左，在字符串str中 找一个字符出现的位置。 返回字符在字符串中的地址。

		char *strrchr(const char *s, int c);

		printf("%s\n" strrchr("hehehahahoho", 'a'));  --> "ahoho"

	strstr():

		在字符串str中，找子串substr第一次出现的位置。返回地址。

		char *strstr(const char *str, const char *substr);

		在字符串中找子串的位置。

		printf("%s\n" strrchr("hehehahahoho", "ho"));  --> "hoho"

		printf("%s\n" strrchr("hehehahahoho", "xixi"));  --> NULL

scanf(“%s”, str);

scanf(“%[^\n]”, str);

字符串分割：

	strtok(): 按照既定的分割符，来拆分字符串。“www.baidu.com”  --> "www\0baidu.com"

	char *strtok(char *str, const char *delim);

		参1： 待拆分字符串

		参2： 分割符组成的“分割串”

	返回：字符串拆分后的首地址。 “拆分”:将分割字符用 '\0'替换。

特性：
	1）strtok拆分字符串是直接在 原串 上操作，所以要求参1必须，可读可写（char *str = "www.baidu.com" 不行！！！）

	2）第一次拆分，参1 传待拆分的原串。	第1+ 次拆分时，参1传 NULL.


练习： 拆分 ".itcast.cn$This is a strtok$test"

	char str[] = "www.itcast.cn$This is a strtok$test";

	char *p = strtok(str， "$ .");

	while (p != NULL)
	{
		p = strtok(NULL, " .$");
		printf("p = %s\n", p);
	}

atoi/atof/atol：

	使用这类函数进行转换，要求，原串必须是可转换的字符串。

	错误使用："abc123" --> 0;	"12abc345" ---> 12;  "123xyz" -->123

	atoi：字符串 转 整数。

	int atoi(const char *nptr);

	atof：字符串 转 浮点数

	atol：字符串 转 长整数

---

局部变量：

概念：定义在函数 内 部的变量。

作用域：从定义位置开始，到包裹该变量的第一个右大括号结束。

全局变量：

概念：定义在函数 外 部的变量。

作用域：从定义位置开始，默认到本文件内部。 其他文件如果想使用，可以通过声明方式将作用域导出。

static全局变量：

定义语法： 在全局变量定义之前添加 static 关键字。		static int a = 10；

作用域：被限制在本文件内部，不允许通过声明导出到其他文件。

static局部变量：

定义语法： 在局部变量定义之前添加 static 关键字。

特性： 静态局部变量只定义一次。在全局位置。 通常用来做计数器。

作用域：从定义位置开始，到包裹该变量的第一个右大括号结束。

全局函数： 函数

定义语法： 函数原型 + 函数体

static函数：

定义语法：static + 函数原型 + 函数体

static 函数 只能在 本文件内部使用。 其他文件即使声明也无效。

生命周期：

局部变量：从变量定义开始，函数调用完成。 --- 函数内部。

全局变量：程序启动开始，程序终止结束。  --- 程序执行期间。

static局部变量：程序启动开始，程序终止结束。  --- 程序执行期间。

static全局变量：程序启动开始，程序终止结束。  --- 程序执行期间。

全局函数：程序启动开始，程序终止结束。  --- 程序执行期间。

static函数：程序启动开始，程序终止结束。  --- 程序执行期间。

内存4区模型：

代码段：.text段。 程序源代码（二进制形式）。

数据段：只读数据段 .rodata段。初始化数据段 .data段。 未初始化数据段 .bss 段。

stack：栈。 在其之上开辟 栈帧。	windows 1M --- 10M	Linux： 8M --- 16M

heap：堆。 给用户自定义数据提供空间。 约 1.3G+

开辟释放 heap 空间：

void *malloc(size_t size);  申请 size 大小的空间

	返回实际申请到的内存空间首地址。 【我们通常拿来当数组用】

void free(void *ptr);	释放申请的空间

	参数： malloc返回的地址值。

使用 heap 空间：

空间时连续。 当成数组使用。

free后的空间，不会立即失效。 通常将free后的 地址置为NULL。

free 地址必须 是 malloc申请地址。否则出错。

如果malloc之后的地址一定会变化，那么使用临时变量tmp 保存。

二级指针对应的 heap空间：

申请外层指针： char **p = (char **)malloc(sizeof(char *) * 5);

申请内层指针： for(i = 0; i < 5; i++)
		{
			p[i] = (char *)malloc(sizeof(char) *10);
		}

使用： 不能修改 p 的值。

	 for(i = 0; i < 5; i++)
	{
		strcpy(p[i], "helloheap");
	}

释放内层：

	 for(i = 0; i < 5; i++)
	{
		free(p[i]);
	}

释放外层：

	free(p);

栈的存储特性：

局部变量：

形参：

内存操作函数：

memset：

memmove：

memcmp：

内存常见问题：

1) 申请 0 字节空间

2）free空指针

3）越界访问

4）free ++后的地址

5）子函数malloc空间，main中用