文章目录
概述
内存
内存含义:
- 存储器:计算机的组成中,用来存储程序和数据,辅助CPU进行运算处理的重要部分。
- 内存:内部存贮器,暂存程序/数据——掉电丢失 SRAM、DRAM、DDR、DDR2、DDR3。
- 外存:外部存储器,长时间保存程序/数据—掉电不丢ROM、ERRROM、FLASH(NAND、NOR)、硬盘、光盘。
内存是沟通CPU与硬盘的桥梁:
- 暂存放CPU中的运算数据
- 暂存与硬盘等外部存储器交换的数据
物理存储器和存储地址空间
有关内存的两个概念:物理存储器和存储地址空间。
物理存储器:实际存在的具体存储器芯片。
- 主板上装插的内存条
- 显示卡上的显示RAM芯片
- 各种适配卡上的RAM芯片和ROM芯片
存储地址空间:对存储器编码的范围。我们在软件上常说的内存是指这一层含义。
- 编码:对每个物理存储单元(一个字节)分配一个号码
- 寻址:可以根据分配的号码找到相应的存储单元,完成数据的读写
内存地址
- 将内存抽象成一个很大的一维字符数组。
- 编码就是对内存的每一个字节分配一个32位或64位的编号(与32位或者64位处理器相关)。
- 这个内存编号我们称之为内存地址。
内存中的每一个数据都会分配相应的地址: - char:占一个字节分配一个地址
- int: 占四个字节分配四个地址
- float、struct、函数、数组等
指针基础知识
指针变量的定义和使用
- 指针也是一种数据类型,指针变量也是一种变量
- 指针变量指向谁,就把谁的地址赋值给指针变量
- “*”操作符操作的是指针变量指向的内存空间
示例:
#include<stdio.h>
int main(void)
{
//定义指针变量存储变量地址
int a = 10;
//指针类型--->数据类型*
int* p;
p = &a;
//通过指针间接改变变量的值
*p = 100;
printf("%p\n", &a);
printf("%p\n", p);
printf("%d\n", a);
printf("%d\n", *p);
return 0;
}
结果:
00A0FA34
00A0FA34
100
100
示例:
#include<stdio.h>
int main(void)
{
//在定义指针类型时一定要和变量的类型对应上
char ch = 'a';
char* p = &ch;
//&是取地址符号是升维度的
//*是取值符号是降维度的
//int a = 10;
//int *p = &a;
//所有的指针类型存储的都是内存地址,内存地址都是一个无符号十六进制整型数
printf("%d\n", sizeof(char*));//4
printf("%d\n", sizeof(int*));
printf("%d\n", sizeof(short*));
printf("%d\n", sizeof(long*));
printf("%d\n", sizeof(long long*));
printf("%d\n", sizeof(float*));
printf("%d\n", sizeof(double*));
return 0;
}
结果:
4
4
4
4
4
4
4
在32位操作系统下所有的指针类型是4个字节大小
在64位操作系统下所有的指针类型是4个字节大小
野指针和空指针
#include <stdio.h>
int main0201(void)
{
//不建议将一个变量的值直接赋值给指针
//野指针---->指针变量指向一个未知的空间
int* p = 100;//程序中允许出现野指针
//操作系统将0-255作为系统占用不允许访问操作
//操作野指针对应的内存空间可能报错
printf("%d\n", *p);
return 0;
}
int main(void)
{
//空指针是指内存地址编号为0的空间
int* p = NULL;
//操作空指针对应的空间一定会报错
*p = 100;
printf("%d\n", *p);
//空指针可以用在条件判断
return 0;
}
万能指针
void *指针可以指向任意变量的内存空间:
示例:
#include<stdio.h>
int main(void)
{
int a = 10;
//int* p = &a;
//万能指针可以接收任意类型变量的内存地址
void* p = &a;
//在通过万能指针修改变量的值时,需要找到变量对应的指针类型
*(int*)p = 100;
printf("%d\n", a);
printf("%d\n", *(int*)p);
printf("万能指针在内存占的字节大小:%d\n", sizeof(void*));
return 0;
结果:
100
100
万能指针在内存占的字节大小:4
const修饰的指针变量
- 指针简介修改常量的值
示例:
#include<stdio.h>
int main(void)
{
//常量
const int a = 10;
//指针间接修改常量的值
int* p = &a;
*p = 100;
printf("%d\n", a);
return 0;
}
结果:
100
- const修饰指针类型
可以修改指针变量的值,不能修改指针指向内存空间的值。
示例:
#include<stdio.h>
int main(void)
{
int a = 10;
int b = 20;
const int* p = &a;
p = &b;//修改指针变量的值 ok
//*p = 100;//修改指针对应的内存空间的值 error
printf("%d\n", *p);
return 0;
结果:
20
- const 修饰指针变量
可以修改指针指向内存空间的值,不可以修改指针变量的值。
示例:
#include<stdio.h>
int main(void)
{
int a = 10;
int b = 20;
int* const p = &a;
//p=&b//不能修改指针变量的值 error
*p = 100;//能修改指针对应的内存空间的值 ok
printf("%d\n", a);
return 0;
结果:
100
总结:const 不能修改离自己近的值,如const int* p = &a;
不能修改*p的值
int* const p = &a;
不能修改 p的值
const修饰指针类型,修饰指针变量
示例:
#include<stdio.h>
int main(void)
{
int a = 10;
int b = 20;
//const修饰指针类型,修饰指针变量 称作只读指针
const int* const p = &a;
//p = &b;//不能修改指针变量 error
//*p = 100;//不能修改指针对应的内存空间的值 error
//二级指针操作
int** pp = &p;
*pp = &b;//*pp是一级指针的值 ok
printf("%d\n", *p);
**pp = 100;//**pp是变量的值 ok
printf("%d\n", *p);
return 0;
}
结果:
20
100
指针和数组
- 数组名字是数组的首元素地址,但它是一个常量
指针操作数组元素
示例:
#include<stdio.h>
int main(void)
{
int arr[] = { 1,2,3,4,5,6,7,'a','b','c' };
//数组名是常量不允许赋值
//arr = 100;//error
//数组名是数组首元素地址
int* p=arr;
printf("%p\n", p);
printf("%p\n",arr);
printf("%d\n", *p);//数组名是数组首元素地址,所以*p表示的是首地址上的元素
printf("\n");
//p++;
//printf("%p\n", arr);//地址的改变
//printf("%p\n", p);
for (int i = 0; i < 10; i++)
{
//printf("%d\n", arr[i]);\\==
//printf("%d\n", *(arr + i));//== 指针类型变量+1,等同于内存地址+sizeof(int)
//如:arr=首地址=0ffx00,arr+1=首地址+1=0xff04
//printf("%d\n", p[i]);//==
printf("%d\n", *p);//地址改变后,打印相应地址对应的变量的值
p++;
}
printf("\n");
//两个指针相减 等于的结果是两个指针的偏移量(步长)
//所有的指针类型相减的结果都是int类型
int step = p - arr;
printf("%d\n", step);
return 0;
}
结果:
0053FB64
0053FB64
1
1
2
3
4
5
6
7
97
98
99
10
示例:
#include<stdio.h>
int main(void)
{
//p和arr的区别
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
//p是变量,arr是常量
printf("指针类型大小:%d\n", sizeof(p));//p是一个指针是4个字节的大小
printf("数组大小:%d\n", sizeof(arr));//arr是一个数组是40个字节的大小
}
return 0;
结果:
指针类型大小:4
数组大小:40
- 数组在作为函数参数的时候就退化为指针了,丢失了数组的精度
示例:
void BubbleSort(int arr[],int len)//数组在作为函数参数的时候就退化为指针了,丢失了数组的精度,所以需要设置len 参数
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
if (arr[j] >arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
/*if (*(arr + j) > *(arr + j + 1))
{
int temp = *(arr + j);
*(arr + j) = *(arr + j + 1);
*(arr + j + 1) = temp;
}*/
}
}
}
int main(void)
{
int arr[] = { 9,1,5,6,3,8,10,7,4,2};
BubbleSort(arr, 10);
for (int i = 0; i < 10; i++)
{
printf("%d\n", arr[i]);
}
return 0;
}
结果:
1 2 3 4 5 6 7 8 9 10
指针加减运算
- 指针计算不是简单的整数相加
- 如果是一个int *,+1的结果是增加一个int的大小
- 如果是一个char *,+1的结果是增加一个char大小
示例: 拷贝字符串
#include<stdio.h>
void my_strcpy01(char ch[], char dest[])//字符串拷贝函数,使用数组写的 ==
{
int i = 0;
while (ch[i] != '\0')
{
dest[i] = ch[i];
i++;
}
dest[i] = 0;
}
void my_strcpy02(char* ch, char* dest)//指针+偏移量
{
int i = 0;
while (*(ch + i)!='\0')
{
*(dest + i) = *(ch + i);
i++;
}
*(dest + i) = 0;
}
void my_strcpy03(char* ch, char* dest)//纯指针
{
while (*ch)
{
*dest = *ch;
dest++;
ch++;
}
*dest = 0;
}
void my_strcpy(char* ch, char* dest)//简便方法
{
while (*dest++ = *ch++);//先取地址对应的变量*ch和*dest,再赋值*dest=*ch,将赋值的结果(*dest=*ch)作为条件进行判断(是否为不等于0),再进行自加1。
}
int main(void)
{
//字符串拷贝
char ch[] = "hello word";
char dest[100];
my_strcpy(ch, dest);
printf("%s\n", dest);
}
结果:
hello word
示例: 指针的加减操作
#include<stdio.h>
int main(void)
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int* p=arr ;
//arr[-1];//数组下标越界
p = &arr[3];
//p--;//指针的加减运算和指针的类型有关
//p--;
//p--;
//内存地址相差是12/sizeof(int)=偏移量
int step = p - arr;
printf("%p\n", p);
printf("%p\n", arr);
printf("%d\n", step);
printf("%d\n", p[-2]);//指针操作数组时,下标允许是负数
return 0;
}
结果:
00D3F8F4
00D3F8E8
3
2
- 两个指针不能相加,但是可以相减,可以+,- 偏移量
- 两个指针不能乘,除,取余
- 指针左右移没有意义
- 两个指针可以比大小
- 指针可以进行逻辑运算
示例:
int main(void)
{
//指针和运算符的操作
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
//p = p + arr;//errror 野指针
//p = p * arr;//error
//p = p * 4;//error
//p=p/arr//error
//int len = p % 4;//error
}
指针数组
指针数组,它是数组,数组的每个元素都是指针类型。
示例:
#include<stdio.h>
int main(void)
{
//定义数组:数组类型 数组名[元素个数]={值1,值2...}
int a = 10;
int b = 20;
int c = 30;
int* arr[3] = { &a,&b,&c };
printf("%d\n", *arr[0]);
printf("\n");//打印一个空行
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d\n", *arr[i]);//*arr[i]不用加括号,因为arr[i]运算级别高于*
}
printf("指针数组大小:%d\n", sizeof(arr));
printf("指针元素大小:%d\n", sizeof(arr[0]));
return 0;
}
结果:
10
10
20
30
指针数组大小:12
指针元素大小:4
示例:
#include<stdio.h>
int main(void)
{
//指针数组里的元素都是指针
int a[] = { 1,2,3 };
int b[] = { 4,5,6 };
int c[] = { 7,8,9 };
//指针数组是一个特殊的二维数组模型
int* arr[] = { a,b,c };
printf("%p\n", arr[0]);//==
printf("%p\n", a);//== 这三个地址均表示数组a的首地址,即&a[0]
printf("%p\n", &a[0]);//==
puts("");
printf("%p\n", arr);//==
printf("%p\n", &arr[0]);//==前两个相等表示指针数组的首地址
printf("%p\n", a);//!=
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
//printf("%d ", arr[i][j]);//二维数组 ==
//printf("%d ", (*arr[i] + j));// *(地址+偏移量) ==
printf("%d ", *(*(arr + i) + j));//== (arr + i)表示指针数组的元素地址,
//*(arr + i)表示指针数组的各个元素,存放的是数组a/b/c的首地址,
//(*(arr + i) + j)表示a/b/c数组的各个元素地址,
//*(*(arr + i) + j))表示a/b/c数组的各个元素
}
puts("");//换行
}
return 0;
}
结果:
0118F84C
0118F84C
0118F84C
0118F810
0118F810
0118F84C
1 2 3
4 5 6
7 8 9
多级指针
- C语言允许有多级指针存在,在实际的程序中一级指针最常用,其次是二级指针。
- 二级指针就是指向一个一级指针变量地址的指针。
- 三级指针基本用不着。
示例:
#include<stdio.h>
int main(void)
{
//指针数组里的元素都是指针
int a[] = { 1,2,3 };
int b[] = { 4,5,6 };
int c[] = { 7,8,9 };
//指针数组是一个特殊的二维数组模型
//指针数组对应于二级指针
int* arr[] = { a,b,c };
//指针数组和二级指针建立关系
int** p = arr;
printf("%d\n", **p);// 1 相当于arr[0][0]
printf("%d\n", **(p + 1));// 4 二级指针加偏移量,相当于跳过了一个一维数组大小
printf("%d\n", *(*p + 1));// 2 相当于arr[0][1] 一级指针加偏移量,相当于跳过了一个元素
printf("%d\n", *(*(p + 1) + 1));// 5
puts("");
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
//printf("%d ", p[i][j]);//== 数组方式
//printf("%d ", *(p[i] + j));//== 指针+数组
printf("%d ", *(*(p + i) + j));//== 纯指针
}
puts("");
}
return 0;
}
结果:
1
4
2
5
1 2 3
4 5 6
7 8 9
示例: a、p、pp的存储结果如图所示
#include<stdio.h>
int main(void)
{
int a = 10;
int b = 20;
int* p = &a;
int** pp = &p;
printf("%p\n", *pp);//== *pp=p=&a
printf("%p\n", p);//==
printf("%p\n", &a);//==
puts("");
*pp = &b;//等价于 p=&b
//**pp = 100;//改变变量的值
//*pp = 100;//野指针 error
printf("%d\n", *p);//20 **pp=*p=b
return 0;
}
结果:
0133FB44
0133FB44
0133FB44
20
示例: 三级指针
#include<stdio.h>
int main(void)
{
int a = 10;
int b = 20;
int* p = &a;
int** pp = &p;
int*** ppp = &pp;
//*ppp == pp == &p;// 三级指针变量 + * = 二级指针变量
//**ppp == *pp == p == &a;// 三级指针变量 + ** = 二级指针 + * = 一级指针变量
//***ppp == **pp == *p == a;// 三级指针变量 + *** = 二级指针变量 + ** = 一级指针变量 + * = 变量
return 0;
}
指针和函数
函数形参改变实参的值
示例: 过程如图所示
#include<stdio.h>
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
void swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int main(void)
{
int a = 10;
int b = 20;
//值传递 形参不影响实参的值
//swap01(a, b);//在函数内部进行交换,不影响外部
//地址传递 形参可以改变实参的值,形参比实参高一个级别
swap(&a, &b);
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
结果:
20
10
数组名做函数参数
数组名做函数参数,函数的形参会退化为指针
示例: 拼接字符串
#include<stdio.h>
void my_strcat01(char ch1[], char ch2[])//== 数组方式
{
int i = 0;
while (ch1[i] != 0)
{
i++;
}
int j = 0;
while (ch2[j] != '\0')
{
ch1[i + j] = ch2[j];
j++;
}
}
void my_strcat02(char* ch1, char* ch2)//== 指针+偏移量
{
int i = 0;
while (*(ch1 + i) != '\0')
{
i++;
}
int j = 0;
while (*(ch2 + j) != '\0')
{
*(ch1 + i + j) = *(ch2 + j);
j++;
}
}
void my_strcat03(char* ch1, char* ch2)//== 指针运算
{
while (*ch1) ch1++;
while (*ch2)
{
*ch1 = *ch2;
ch1++;
ch2++;
}
}
void my_strcat(char* ch1, char* ch2)//== 简便
{
while (*ch1) ch1++;
while (*ch1++ = *ch2++);
}
int main(void)
{
char ch1[100] = "hello";
char ch2[] = "world";
my_strcat(ch1, ch2);
printf("%s\n", ch1);
return 0;
}
结果:
helloworld
示例: 字符串取空格
方法一:
#include<stdio.h>
void remove_space(char* ch)//字符串去空格
{
char str[100] = { 0 };//str初始化
char* temp = str;
int i = 0;
int j = 0;
while (ch[i] != '\0')
{
if (ch[i] != ' ')
{
str[j] = ch[i];
j++;
}
i++;
}
while(*ch++=*temp++);
}
int main(void)
{
char ch[] = "h e ll o w o rl d ";
remove_space(ch);
printf("%s\n", ch);
return 0;
}
方法二:
#include<stdio.h>
void remove_space(char* ch)
{
char* ftemp = ch;//用来遍历字符串
char* rtemp = ch;//记录非空字符串
while (*ftemp)
{
if (*ftemp != ' ')
{
*rtemp = *ftemp;
rtemp++;
}
ftemp++;
}
*rtemp = 0;
}
int main(void)
{
char ch[] = "h e ll o w o rl d ";
remove_space(ch);
printf("%s\n", ch);
return 0;
}
结果:
helloworld
指针做为函数的返回值
示例: 在字符串中查找字符第一次出现的位置
#include<stdio.h>
char* my_strchr01(char* str, char ch)//在字符串中查找字符第一次出现的位置
{
int i = 0;
while (str[i])
{
if (str[i] == ch)
{
return &str[i];
}
i++;
}
return NULL;
}
char* my_strchr(char* str, char ch)
{
while (*str)
{
if (*str = ch)
return str;
str++;
}
return NULL;
}
int main(void)
{
char str[] = "hello world";
char* p = my_strchr(str, 'l');
if (p ==NULL)
{
printf("未找到");
}
else
{
printf("%p\n", p);
}
return 0;
}
结果:
0053F8F0
示例: 查找字符串
#include<stdio.h>
char* my_strstr(char* src, char* dest)
{
char* fsrc = src;//遍历源字符串指针
char* rsrc = src;//记录相同字符串首地址
char* tdest = dest;//目标字符串回滚
while (*fsrc)
{
rsrc = fsrc;
while (*fsrc == *tdest && *fsrc!='\0')
{
fsrc++;
tdest++;
}
if (*tdest == '\0')
{
return rsrc;
}
//回滚
tdest = dest;//目标字符串更新到起始位置
fsrc = rsrc;
fsrc++;
}
return NULL;
}
int main(void)
{
char src[] = "hello world";
char dest[] = "llo";
char* p = my_strstr(src, dest);
printf("%s\n", p);
}
结果:
llo world
指针和字符串
字符指针
- 由指针定义的字符串,是数据区常量区字符串,不可修改,可多个指针指向同一个地址。
示例:
#include<stdio.h>
int main(void)
{
//char ch[] = "hello world";
//char* p = ch;
//printf("%s\n", p);
//printf("%c\n", *p);//打印首字母
char ch[] = "hello world";//栈区字符串,可修改
char* p = "hello world";//数据区常量区字符串,不可修改,可多个指针指向同一个地址(存储字符串相同的不同指针,其地址一样)
ch[2] = 'w';
//p[2] = 'w';//error
printf("%s\n", ch);
printf("%s\n", p);
return 0;
}
示例: 字符串数组
#include<stdio.h>
int main(void)
{
//指针数组
/*char ch1[] = "hello";
char ch2[] = "world";
char ch3[] = "xiaokeai";
char* arr[] = { ch1,ch2,ch3 };*/ //可修改
//字符串数组
char* arr[] = { "hello","world","biaokeai" };//不可修改
/*for (int i = 0; i < 3; i++)
{
printf("%s\n", arr[i]);
}*/
//字符串排序
for (int i = 0; i < 3-1; i++)
{
for (int j = 0; j < 3-1-i; j++)
{
if (arr[j][0] > arr[j + 1][0])//首字符进行比较
{
char* temp = arr[j];//交换指针数组元素进行排序
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < 3; i++)
{
printf("%s\n", arr[i]);
}
return 0;
}
结果:
biaokeai
hello
world
字符指针作函数参数
示例:
#include<stdio.h>
int my_strlen01(char ch[] )//计算字符串有效长度,数组实现
{
int i = 0;
while (ch[i] != '\0')
i++;
return i;
}
int my_strlen(const char* ch)//指针实现,加const 表示内容不能被修改
{
char* temp = ch;
while (*temp)
temp++;
return temp - ch;
}
int main(void)
{
char ch[] = "hello world";
int len = my_strlen(ch);
printf("%d\n", len);
return 0;
}
结果:
11
const修饰的指针变量
示例:
#include<stdio.h>
int main0301(void)
{
const int a = 10;
//通过一级指针间接修改变量的值
int* p = &a;
*p = 100;
return 0;
}
int main0302(void)
{
char ch1[] = "hello";
char ch2[] = "world";
const char* p = ch1;//指向常量的指针,可以修改指针变量的值,不可以修改指针变量指向内存空间的值
//*p='m'//error 不能修改*p,即ch1的首字母
//p[2]='m'//error
p = ch2;//ok 可以修改p的指向
printf("%s\n", p);
printf("%s\n", ch2);
return 0;
}
int main0303(void)
{
char ch1[] = "hello";
char ch2[] = "world";
char* const p = ch1;//指针常量,可以修改指针变量指向内存空间的值,不能修改指针变量的值
*p = 'm';//ok 可以修改*p
//p[2] = 'm';//ok
//*(p + 2) = 'm';
//p = ch2;//error,不能修改p的指向
printf("%s\n", p);
printf("%s\n", ch1);
return 0;
}
int main(void)
{
char ch1[] = "hello";
char ch2[] = "world";
const char* const p = ch1;
//*p = 'm';//error
//p[2] = 'm';//error
//p = ch2;//error
char** p1 = &p;
//*p1 = ch2;//ok
*(*p1 + 1) = 'm';
printf("%s\n", p);
return 0;
}
结果:
hmllo
指针数组做为main函数的形参
- main函数是操作系统调用的,第一个参数标明argc数组的成员数量,argv数组的每个成员都是char *类型
- argv是命令行参数的字符串数组
- argc代表命令行参数的数量,程序名字本身算一个参数
示例: 主函数参数
#include<stdio.h>
//gcc -o hello heool.c (4个参数 "gcc" "-o" "hello" "hello.c")
//int argc表示传递参数的个数
//char*argv[]={"gcc","-o","hello","hello.c"} 表示参数具体内容
int main(int argc, char* argv[])
{
int i;
for (i = 0; i < argc; i++)
{
printf("%s\n", argv[i]);
}
return 0;
}
- 此程序须在外部进行运行
- 打开程序的文件所在位置—win+r—cmd—输入gcc -o—将代码.c文件拖入进去—将.c改成.exe—空格—再将代码.c文件拖入进去—回车
-
若程序中的for 循环写的是
for (int i = 0; i < argc; i++)
则需要在5后面加-std=c99
-
然后将生成的.exe文件拖入—在后面写入 nichousha jiuchoule —回车
项目开发常用字符串应用模型
- while和do-while模型
示例: 查找字符串中部分字符串出现的次数
#include<stdio.h>
char* my_strstr(char* src, char* dest)
{
char* fsrc = src;//遍历源字符串指针
char* rsrc = src;//记录相同字符串首地址
char* tdest = dest;//目标字符串回滚
while (*fsrc)
{
rsrc = fsrc;
while (*fsrc == *tdest && *fsrc != '\0')
{
fsrc++;
tdest++;
}
if (*tdest == '\0')
{
return rsrc;
}
//回滚
tdest = dest;//目标字符串更新到起始位置
fsrc = rsrc;
fsrc++;
}
return NULL;
}
int main0501(void)//while 模型
{
char* str = "11abcd111122abcd333abcd3322abcd3333322qqq";
char ch[] = "abcd";
char* p = my_strstr(str, ch);
int count = 0;//记录个数
while (p != NULL)
{
count++;
p += strlen(ch);
p = my_strstr(p, ch);
}
printf("abcd在字符串中出现:%d次\n", count);
return 0;
}
int main(void)//do-while模型 先执行do语句再进行while条件判断
{
char* str = "11abcd111122abcd333abcd3322abcd3333322qqq";
char ch[] = "abcd";
char* p = my_strstr(str, ch);
int count = 0;
do
{
if (p)
{
count++;
p += strlen(ch);
p = my_strstr(p, ch);
}
} while (p);
printf("%d\n", count);
return 0;
}
结果:
4
示例: 去除空格后的字符串个数
# include<stdio.h>
int get_mystrcount01(char* str)//数字方法
{
int i = 0;
int count = 0;
while(str[i])
{
if (str[i] != ' ')
{
count++;
}
i++;
}
return count;
}
int get_mystrcount(char* str)//指针
{
int count = 0;
while (*str )
{
if ( *str!= ' ')
{
count++;
}
str++;
}
return count;
}
int main(void)//去空格字符串个数
{
char str[] = " he llo world ";
int len = get_mystrcount(str);
printf("%d\n", len);
return 0;
}
结果:
10
**示例:**统计字符出现的次数
int main(void)//统计字符出现次数
{
char ch[] = "helloworldshenmeshikuailexingqiuruoguonixiangzhidaoshenmeshikuailexingqiudehuawohuipeiniyaojiu";
//存储字符串出现次数
int arr[26] = { 0 };//数组初始化
for (int i = 0; i < strlen(ch); i++)
{
arr[ch[i] - 'a']++;
}
for (int i = 0; i < 26; i++)
{
if (arr[i] != 0)
{
printf("字符:%c\t出现的次数是:%d\n", 'a' + i, arr[i]);
}
}
return 0;
}
结果:
字符:a 出现的次数是:6
字符:d 出现的次数是:3
字符:e 出现的次数是:9
字符:g 出现的次数是:4
字符:h 出现的次数是:8
字符:i 出现的次数是:15
字符:j 出现的次数是:1
字符:k 出现的次数是:2
字符:l 出现的次数是:5
字符:m 出现的次数是:2
字符:n 出现的次数是:7
字符:o 出现的次数是:7
字符:p 出现的次数是:1
字符:q 出现的次数是:2
字符:r 出现的次数是:2
字符:s 出现的次数是:4
字符:u 出现的次数是:9
字符:w 出现的次数是:2
字符:x 出现的次数是:3
字符:y 出现的次数是:1
字符:z 出现的次数是:1
- 字符串反转模型
示例:
#include<stdio.h>
void inverse01(char* ch)
{
int i = 0;
int j = strlen(ch) - 1;
while (i < j)
{
int temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
i++;
j--;
}
return;
}
void inverse(char* ch)
{
char* ftemp =ch;
char* btemp = ch + strlen(ch) - 1;
while (ftemp < btemp)
{
char temp = *ftemp;
*ftemp = *btemp;
*btemp = temp;
ftemp++;
btemp--;
}
return;
}
int main(void)
{
char ch[] = "hello world";
inverse(ch);
printf("%s\n", ch);
return 0;
}
结果:
dlrow olleh
示例: 回文字符串
#include<stdio.h>
//回文字符串
//abcba abccba
int symm(char* ch)
{
char* ftemp = ch;
char* btemp = ch + strlen(ch) - 1;
while (ftemp < btemp)
{
if (*ftemp != *btemp)
return 1;
ftemp++;
btemp--;
}
return;
}
int main(void)
{
char ch[] = "abcba";
int value = symm(ch);
if (value == 1)
printf("不相同\n");
else
printf("相同\n");
return 0;
}
结果:
相同
字符串处理函数
- strcpy() 字符串拷贝
- 功能:把src所指向的字符串复制到dest所指向的空间中,'\0’也会拷贝过去。
- 需要引入头文件
#include<string.h
> - 在开始要引入
#define _CRT_SECURE_NO_WARNINGS
警告话语 - 如果参数dest所指的内存空间不够大,可能会造成缓冲溢出的错误情况。
示例: 调用strcpy()函数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main(coid)
{
char ch[] = "hello world";
char str[100];
strcpy(str, ch);
printf("%s\n",str);
return 0;
}
示例: 自己写的拷贝函数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
void my_strcpy(char* dest, const char*src)
{
while (*dest++ = *src++);
}
int main(coid)
{
char ch[] = "hello world";
char str[100];
//strcpy(str, ch);
my_strcpy(str, ch);
printf("%s\n",str);
return 0;
}
结果:
hello world
- strncpy() 字符串的有限拷贝
示例: 字符串的有限拷贝
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
void my_strncpy(char* dest, const char*src, size_t n)
{
while ((*dest++ = *src++)&& --n);
}
int main(coid)
{
char ch[] = "hello world";
char str[100] = { 0 };//有限拷贝不一定将\0拷贝进来,所以需要对字符串进行初始化
//strncpy(str, ch, 5);
my_strncpy(str, ch, 5);
printf("%s\n",str);
return 0;
}
结果
hello
- strcat() 字符串连接
示例: 全部追加
#include<stdio.h>
void my_strcat(char* dest, char* src)
{
while (*dest)dest++;
while (*dest++ = *src++);
}
int main(void)
{
char dest[100] = "hello";
char src[] = "world";
//strcat(dest, src);
my_strcat(dest,src);
printf("%s\n", dest);
return 0;
}
结果:
heloworld
- strncat() 字符串有限追加
示例:
#include<stdio.h>
void my_strncat(char* dest, char* src,size_t n)
{
while (*dest)dest++;//找到dest字符串中\0的位置
while ((*dest++ = *src++)&& --n);
}
int main(void)
{
char dest[100] = "hello";
char src[] = "world";
//strncat(dest, src, 2);//有限追加
my_strncat(dest, src, 2);
printf("%s\n", dest);
return 0;
}
结果:
hellowo
- strcmp() 字符串比较
示例: 比较全部字符串
#include<stdio.h>
int my_strcmp01(const char* ch1, const char* ch2)
{
while (*ch1 == *ch2)
{
if (*ch1 == '\0')
{
return 0;
}
ch1++;
ch2++;
}
return *ch1 > *ch2 ? 1 : -1;
}
int main(void)
{
char ch1[] = "hello world";
char ch2[] = "hello world";
//int value=strcmp(ch1, ch2);//相同时返回0
int value = my_strcmp(ch1, ch2);
printf("%d\n", value);
return 0;
}
结果:
1
- strncmp() 比较有限个数的字符串
示例:
#include<stdio.h>
int my_strncmp(const char* ch1, const char* ch2,size_t n)//有限字符串比较
{
for (int i = 0; i < n && ch1[i] && ch2[i]; i++)
{
if (ch1[i] != ch2[i])
{
return ch1[i] > ch2[2] ? 1 : -1;
}
}
return 0;
}
int main(void)
{
char ch1[] = "hello world";
char ch2[] = "hello mike";
//int value = strncmp(ch1, ch2,5);
int value = my_strncmp(ch1, ch2, 7);
printf("%d\n", value);
return 0;
}
结果:
1
- sprintf() 字符串格式化,写入
示例:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void)
{
char ch[100];
//sprintf(ch, "hello world");//将字符串写入到ch 中
//sprintf(ch, "%d+%d=%d", 1, 2, 3);
//sprintf(ch, "%02d+%02d=%02d", 1, 2, 3);
sprintf(ch, "%x+%o=%d",0xabc, 110, 3);
printf("%s\n", ch);
return 0;
}
结果:
abc+156=3
- sscanf() 读取
示例:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void)
{
//char ch[] = "1+2=3";
char ch[] = "hello world";
int a, b, c;
char str1[100];
char str2[100];
//sscanf(ch, "%d+%d=%d", &a, &b, &c);
//sscanf(ch, "%[^\n]", str);//%[^\n] 防止遇到空格而停止
//sscanf(ch, "%4s", str);// 打印4个字符
sscanf(ch, "%5s%s", str1, str2);
/*printf("%d\n", a);
printf("%d\n", b);
printf("%d\n", c);*/
printf("%s\n", str1);
printf("%s\n", str2);
return 0;
}
结果:
hello
world
存储的时候可以将空格存进去,但是读取的时候空格会被当做结束标志,结束读取,所以需要%[^\n]
来防止遇空格停止读取。
- strchr()
示例:
# include<stdio.h>
char* my_strchr00(char* s, int c)
{
while (*s)
{
if (*s == c)
return s;
s++;
}
return NULL;
}
int main(void)
{
char ch[] = "hello world";
char c = 'l';
//char* p=strchr(ch, c);
char* p = my_strchr00(ch,c);
printf("%s\n", p);
}
结果:
llo world
- strstr()
示例:
#include<stdio.h>
int main(void)
{
char ch[] = "hello world";
char str[] = "llo";
char* p = strstr(ch, str);
printf("%s\n", p);
return 0;
}
结果:
llo world
- strtok() 字符串分割
示例:
#include<stdio.h>
//字符串截取strtok会破坏源字符串,会用\0替换分割的标志位
int main(void)
{
char ch[] = "www.itcast.cn!";//截取后的字符串变成www\0itcast.cn
char* p = strtok(ch, ".");//截取后的字符串变成www\0itcast.cn
printf("%s\n", p);
//printf("%s\n", ch);
p = strtok(NULL, ".");//截取后的字符串变成www\0itcast\0cn,使用NULL是因为字符串没有截取完在缓存区又保留一份,所以用NULL
printf("%s\n", p);
p = strtok(NULL, ".");//若到末尾还没有找到分隔符,则全部输出
printf("%s\n", p);
/*printf("%p\n", p);
printf("%p\n", ch);*/
return 0;
}
结果:
www
itcast
cn!
示例:
#include<stdio.h>
int main1302(void)
{
char ch[] = "123456789@qq.com";
char str[100] = { 0 };
//字符串备份
strcpy(str, ch);
char* p = strtok(str, "@");
printf("%s\n", p);
p = strtok(NULL, ".");
printf("%s\n", p);
return 0;
}
int main(void)//循环打印
{
//char ch[] = "shenmeshikuailexingqiu\nruguonixiangzhidaoshenmeshikuailexingqiudehua\nwojiudainiyanjiu";
char ch[] = "什么是快乐星球\n如果你想知道什么是快乐星球的话\n我就带你研究";
char* p = strtok(ch, "\n");
while (p)
{
printf("%s\n", p);
p = strtok(NULL, "\n");
}
return 0;
}
- atoi()
类似的函数有: - atof():把一个小数形式的字符串转化为一个浮点数。
- atol():将一个字符串转化为long类型。
示例:
#include<stdio.h>
int main1401(void)
{
char ch[] = " -123-456abc123";//输出为-123
int i = atoi(ch);
printf("%d\n", i);
return 0;
}
int main1402(void)
{
char ch[] = " -123.456-456abc123";//
double i=atof(ch);
printf("%f\n", i);
return 0;
}
int main(void)
{
char ch[] = " -123.456-456abc123";
long i = atol(ch);
printf("%ld\n", i);
return 0;
}
总结