第七周:指针与字符串学习笔记--C语言
程序员文章站
2022-04-17 08:45:32
7-1指针初步
7-1-1类型大小与取地址运算
sizeof是一个运算符
给出某个变量货类型在内存中所占据的字节数
sizeof(int); sizeif(i);...
7-1指针初步
7-1-1类型大小与取地址运算
sizeof是一个运算符
给出某个变量货类型在内存中所占据的字节数
sizeof(int); sizeif(i);
double变量在内存中占据的空间是int变量的两倍
{ int a; a =6; printf("sizeof(int)=%ld\n",sizeif(int)); printf("sizeof(a)=%d\n",sizeof(a)); return 0; } --->sizeof(int)=4 sizeof(a)=4
运算符 &
scanf(“%d”,&i);里的 &
· 取得变量的地址,它的操作数必须是变量int i;prinf("0x%x",&i);
–>Ox9ffe4c //%x 16进制
地址的大小是否与int相同,取决于编译器
· & 可以帮忙取出一个变量的地址,但是这个地址的大小,数据类型,与int是否相等取决于编译器,取决于是64还是32位架构int i;printf("%p",&i);
要输出地址,用%p,而不是直接当成整数,地址和整数不总是相等的
{ int i=0; printf("0x%x\n",&i); printf("%p\n",&i); printf("%lu\n",sizeof(int)); printf("%lu\n",sizeof(&i)); return 0; } --->0xbff62d6c 0xbff62d6c 4 4 8(64位) 4(32位)& 不能对没有地址的东西取地址
·&(a+b) X
·&(a++) X
·&(++a) X 试试这些&
·变量的地址
·相邻的变量的地址
·&的结果的sizeof
·数组的地址
·数组单元的地址
·相邻的数组单元的地址
{ int i =0; int p; printf("%p\n",&i); printf("%p\n",&p); return 0; } --->0xbff81d6c 0xbff81d68 堆栈stack自顶向下
int a[10]; printf("%p\n",&a); printf("%p\n",a); printf("%p\n",&a[0]); printf("%p\n",&a[1]); return 0; --->0xbff8dd44 0xbff8dd44 0xbff8dd44 0xbff8dd48 -->&a==a==&a[0]
7-1-2指针
scanf
如果能将取得的变量的地址传递给一个函数,能否通过这个地址在那个函数内访问这个变量? scanf(“%d”,&i); scanf()的原型应该是怎么样的?我们需要一个参数能保存别的变量的地址,如何表达能够保存有地址的变量
就是保存地址的变量
int i;
int* p=&i;
*表示p是一个指针,它指向一个int,把i的地址给了pp指向i,P里面的值就是i变量的地址
int* p,q;
*可以靠近int也可以靠近P,但意思一样,说明P是一个指针,指向一个int int *p,q;
而q只是一个普通的int类型的变量 *不是加给了int,而是加给了p
指针变量 变量的值是内存的地址
· 普通变量的值是实际的值
· 指针变量的值是具有实际值的变量的地址
· void f(int *p);
· 在被调用的时候得到了某个变量的地址: int i = 0; f(&i);
· 在函数里面可以通过这个指针访问外面的这个i 访问那个地址上的变量 *
· *是一个单目运算符,用来访问指针所指的值所表示的地址上的变量
· 可以做右值,也可以做左值
· int k =*p;
· *p =k+1;
#include void f (int* p); void g (int k); int main(void){ int i=6; printf("&i=%p\n",&i); //看下i的地址 f(&i); g(i); return 0; } void f (int *p){ //p得到的是i的地址,使得拥有了能够访问外面的i的能力了 printf(" p=%p\n",p); printf("*p=%d\n",*p); //*和指针变量p放在一起作为一个整体,表示一个整数 *p=26; //实际是对i做的 } void g (int k){ //在g里面k变量得到的只是i的值,跟外面的i没有任何关系 printf(" k=%d\n",k); } ===>&i=0xbffbcd70 p=0xbffbcd70 *p=6 k=26 //经历了f函数的调用,i的值被改了
7-1-3指针与数组
传入函数的数组成了什么?
如果是普通变量,接收的是值;如果是指针,接收的是指针的值,
函数参数表中的数组参数实际上是指针
sizeif(a[])==sizeof(*int)
但可以用数组的运算符[]进行运算 数组参数 以下四种函数原型是等价的
int sun(int *ar,int n);
int sun(int *,int);
int sun(int ar[],int n);
int sun(int ar[],int); 数组变量是特殊的指针
数组变量本身表达的是地址,所以
int a[10];int*p=a;//无需用&取地址
但数组的单元表达的是变量
a==&a[0] []运算符可以对数组做,也可以对指针做:
p[0]<==>a[0] *运算符可以对指针做,也可以对数组做:
*a=25 //*a可以取数组a[0] 数组变量是const的指针,所以不能被赋值
int a[]<==>int *const a=…
======================================
7-2字符类型
7-2-1字符类型
字符类型
char(character)是一种整数,也是一种特殊的类型:字符。这是因为:
· 用单引号表示的字符字面量’a’,’1’
· ”也是一个字符
· printf和scanf里用%c来输入输出字符 字符的输出输入
如何输入’1’这个字符给char c?
scanf("%c",&c);-->1
scanf("%d",&i);-->49
‘1’的ASKII编码是49,所以当c==49时,他代表’1’
if(49=='1'){printf("OK");} --->OK
一个49各自表述
int main (void){ char c; char d; c=1; d='1'; if(c==d){ printf("相等\n"); }else{ printf("不相等\n"); } printf("c=%d\n",c); printf("d=%d\n",d); return 0; } --->不相等 c=1 d=49
int main (void){ char c; scanf("%c",&c); printf("c=%d\n",c); printf("c=%c\n",c); return 0; } 输入:1 输出:c=49 c=1
int main (void){ int c; scanf("%d",&c); printf("c=%d\n",c); printf("c=%c\n",c); return 0; } 输入:1 输出:c=49 c=" "
int main (void){ int i; int c; scanf("%d",&i); c=i; //整数49交给了c printf("c=%d\n",c); //c做为整数输出是49 printf("c='%c'\n",c); //c做为字符输出是1 return 0; } 输入:49 输出:c=49 c="1"混合输入
有何不同
scanf("%d %c",&i,&c);
有空格会把空格读掉 12 1;读到12和1//12a;读到12和a//12 a;读到12和a
scanf("%d%c",&i,&c);
没有空格只读到整数 12 1;读到12和空格//12a;读到12和a//12 a读到12和空格 字符计算
一个字符加一个数字得到ASCII码表中那个数之后的字符
char c='A'; c++; printf("%c\n",c);--->B
两个字符的减,得到他们在表中的距离int i='Z'-'A'; printf("%d\n",i);--->25
大小写转换字母在ASCII表中是顺序排列的 大写字母和小写字母是分开排列的,并不在一起 ‘a’-‘A’得到两段之间的距离,于是:
· A+’a’-‘A’可以把一个大写字母变成小写字母,而
· a+’A’-‘a’可以把一个小写字母变成大写字母
7-2-2逃逸字符
逃逸字符
用来表达无法印出来的控制字符或特殊字符,他由一个反斜杠”\”开头,后面跟上另一个字符,这两个字符组合起来,组成了一个字符
printf("请分别输入身高的英尺和英寸","如输入\"5 7\"表示5英尺7英寸:")
\”表示一个字符,就是双引号,因为在双引号之内不能再出现双引号
字符 | 意义 | 字符 | 意义 |
---|---|---|---|
\b | 回退一格 | \” | 双引号 |
\t | 到下一个表格位 | \’ | 单引号 |
\n | 换行 | \|反斜杠本身 | |
\r | 回车 |
每行的固定位置 一个\t使得输出从下一个制表位开始 用\t才能使上下两行对齐
======================================
7-3字符串
7-3-1字符串
字符数组
char word []={‘H’,’e’,’l’,’l’,’o’,’!’}; 这不是C语言的字符串,因为不能用字符串的方式做计算
word[0] | H |
---|---|
word[1] | e |
word[2] | l |
word[3] | l |
word[4] | o |
word[5] | ! |
char word []={‘H’,’e’,’l’,’l’,’o’,’!”’\0’};
word[0] | H |
---|---|
word[1] | e |
word[2] | l |
word[3] | l |
word[4] | o |
word[5] | ! |
word[6] | \0 |
以0结尾的一串字符
· 0和\0是一样的,单核’0’不同 0标志字符串的结束,但它不是字符串的一部分,
· 计算字符串长度的时候不包含这个0 字符串以数组的形式存在,以数字或指针的方式访问
· 更多的是以指针的形式 String.h里有很多处理字符串的函数 字符串变量
char *str =’hello’;
有一个指针,名字是str,指向一个字符数组,里面放的内容是hello char word[]=’hello’;
这有一个字符数组,里面的内容是hello char line[10]=’hello’;
有个字符数组叫line,大小有10个字节,往里面放了hello,hello总共有5个字符,占据6个空间位置,因为还有结尾的0。 记住写出的字符串编译器会加上一个结尾的0 字符串常量
”hello” 由双引号括起来,在C语言中叫做字面量,或者叫做字符串常量 “hello” 会被编译器变成一个字符数组放在某处,这个数组的长度是6,结尾还有表示结束的0 两个相同的字符串常量会被自动连接起来 字符串
C语言的字符串是以字符数组的形态存在的
· 不能用字符串对字符串做运算
· 过数组的方式可以便利字符串 唯一特殊的地方是字符串字面量可以用来初始化字符数组 以及标准库提供了一系列字符串函数
[注]: C语言70年代更注重处理数字,80年代之后的语言才开始侧重处理信息,处理字符串
7-3-2字符串输入输出
字符串赋值?
char *t=”title”; char *s; s=t; 并没有产生新的字符串,只是让指针s指向了t所指的字符串,对s的任何操作就是对t做的 字符串输入输出
char string[8]; scanf (“%s”,string); printf(“%s”,string); scanf读入一个单词(到空格,tab,或回车为止) scanf是不安全的,因为不知道要读入的内容的长度
scanf ("%7s",string);
int main() { char word[8]; char word2[8]; scanf ("%s",word); scanf ("%s",word2); printf("%s##%s##\n",word,word2); } 输入hello world! 输出hello##world!##安全的输入
char string[8]; scanf(“%7s”,string); 在%和s之间的数字表示最多允许读入的字符的数量,这个数字应该比数组的大小小一
下一次scanf从哪开始?从第八个开始读,不管空格 常见错误
char *string; 只是定义了一个指针,没有被初始化 scanf(“%s”,string); 以为char *是字符串类型,定义了一个字符串类型的变量string就可以直接使用了。这就是为什么在我这是对的,去那就错了 由于没有对string初始化为0,所以不一定每次运行都出错 空字符串
char buffer[100]=”“;
这是一个空的字符串,buffer[0]==’\0’ char buffer[]=”“;
这个数组的长度只有1!这个字符串里放不下任何字符串
7-3-3字符串函数
string.h
#include
strlensize_t strlen(const char *s)
返回s的字符串长度(不包括结尾的0) [说明]length长度,作为参数,数组的形式和指针的形式是一样的,因为数组传进去也是指针,这里用指针的形式表达,const保证不会修改字符串
#include #include int main(void) { char line[] ="hello"; printf("strlen=%lu\n",strlen(line)); printf("sizeof=%lu\n",sizeof(line)); return 0; }-->strlen=5 sizeof=6strcmp
int strcmp(const char *s1,const char *s2)
//compare比较 比较两个字符串,返回0:s1==s2//1:s1>s2//-1:s1< s2 [说明]
#include #include int main(void) { char s1[] ="abc"; char s2[] ="Abc"; printf("%d\n",s1==s2);//数组的比较永远是false,因为两个数组永远不会是相同的地址,用==比较是否是相同的地址 printf("%d\n",strcmp(s1,s2)); return 0; }-->0 1strcpy
char * strcpy(char *restrict dst,const char *restrict src);
//copy复制 把src的字符串拷贝到dstrestrict表明src和dst不重叠 返回dst
为了能链起代码来 strcat
char * strcat(char *restrict s1,const char *restrict s2)
//链接 把s2拷贝到s1后面,接成一个长的字符串 返回s1 s1必须具有足够的空间 安全问题strcpy和strcat都可能出现安全问题,如果目的地没有足够的空间? 安全版本
char * strncpy(char *restrict dst,const char *restrict src,size_t n);
n对于拷贝,最多能够拷过去多少个字符,安全不会越界
char * strncat(char *restrict s1,const char *restrict s2,size_t n)
n对于cat,最多能够cat多少个字符
int strncmp(const char *s1,const char *s2,size_t n)
判断开头三个字母是不是abc,只判断前n个 strchr字符串中找字符
char *strchr(const char *s,int c);
从左边找过来寻找c第一次出现的位置,返回指针
char *strrchr(const char *s,int c);
从右边找过来寻找c第一次出现的位置,返回指针 返回NULL表示没找到 如何找第2个? strstr
1.对于:
int a[] = {5, 15, 34, 54, 14, 2, 52, 72};
int *p = &a[5];
则:p[-2]的值是?
A.编译出错,因为数组下标越界了
B.行出错,因为数组下标越界了
C.54
D.2 2.如果:
int a[] = {0};int *p = a;
则以下哪些表达式的结果为真?A.p == a[0]
B.p == &a[0]
C.*p == a[0]
D.p[0] == a[0] 3.以下代码片段是正确的吗?
char* s;scanf("%s", s);
A.√
B.× 没有给指针s初始化地址 4以下变量定义:
int* p,q;
中,p和q都是指针。A.√
B.× p是q不是 5以下运算的结果是:1
'b'-'a'