一、字符数组？
1、什么是字符数组？
一个数组中全部成员都是字符来的。
例子： char A[5];
2、字符数组赋值？
1）定义同时初始化？
char A[10] = {'h','e','l','l','o'}; -> 剩余没有赋值的5个元素都为0
char A[10] = {"hello"}; -> 将字符串hello赋值给数组
char A[10] = {"10086"}; -> char A[10]已经决定每一个成员都是字符类型，所以 '1','0','0','8','6'
int A[10] = {1,0,0,8,6}; -> int A[10]已经决定每一个成员都是整型类型，所以 1,0,0,8,6
char A[10] = "hello"; -> {}可以省略！
3、将字符串常量赋值给数组在内存中是如何变化？
int a = 10;
char A[10] = "hello";
其实将常量区中的值赋值给栈区空间。
1）注意：
所有字符串常量在常量区存在都会以' '作为结束的标志。
Oct Dec Hex Char
000 0 00 NUL ' '
2）例如：
hello world apple tree
二、字符指针？
整型指针 -> int类型
字符指针 -> char类型
例子1：
char a = 'h';
char *p = &a; -> p就是字符指针 -> 指向一个字符类型的数据a
例子2：
char *p = "hello"; -> 正确!
究竟p指向字符？还是指向一个字符串？
字符指针p永远只能指向字符，不可能指向整个字符串，在这个例子，p指向"hello"这个字符串的首元素'h'的地址
注意：
1）p是一个指针变量，所以只能存放地址，存放着是hello中'h'的地址。
2）p是一个指针变量，不能存放字符串，不是将常量区的hello拷贝过来。
3）字符指针只能指向字符，不能指向字符串。
4）%s 输出字符串
输出原则：给定一个地址，判断地址上值是不是' '。
如果不是 ，则打印该地址上的值并将该地址往后挪动一个单位。
如果是 ，就停止打印。
请问以下代码是什么含义？
char A[10] = "hello";
char *p = "hello";
printf("A = %s ",A); //A是字符串首元素的地址，结果：hello -> 打印的是栈区的hello
printf("p = %s ",p); //p是字符串首元素的地址，结果：hello -> 打印的是常量区的hello
结论：
1）只要将一个字符串赋值给一个字符数组，那么就会把常量区的字符串拷贝到该字符数组中。
2）只要将一个字符串赋值给一个字符指针，那么该指针就是存放着这个字符串的首元素的地址。
#include <stdio.h>
int main(int argc,char *argv[])
{
char A[] = "helloworld";
char *p = "helloworld";
char *pa = A; //pa等价于数组名A，使用pa来访问东西，都是属于栈区！
printf("sizeof(A) = %d ",sizeof(A));//11
printf("sizeof(p) = %d ",sizeof(p));//4
printf("A = %s ",A); //helloworld
printf("*A = %c ",*A); //h 栈区
printf("*(A+1) = %c ",*(A+1)); //e 栈区
printf("A+1 = %s ",A+1); //elloworld 栈区
printf("p = %s ",p); //helloworld 常量区
printf("pa = %s ",pa); //helloworld 栈区
printf("A[0] = %c ",A[0]); //h 栈区
A[0] = 'k';
printf("A = %s ",A); //kelloworld 栈区
printf("*p = %c ",*p); //h 常量区
//*p = 'k'; //26行段错误，原因常量区不能修改值。
//printf("p = %s ",p);
printf("*pa = %c ",*pa); //k 栈区
pa[0] = 'm';
printf("pa = %s ",pa); //melloworld
return 0;
}
14、有以下程序
main()
{
char s[]=“Yes /No”,*ps=s;
puts(ps+4);
*(ps+4)=0;
puts(s);
}
程序运行后的输出结果是( B )
A) n/No B) /No C) n/No D) /No
Yes Yes Yes /No
/No /No Yes
16、有以下程序
main()
{
char s[]= “ABCD”,*p;
for(p=s+1;p<s+4;p++)
printf(“%s ”,p);
}
程序运行后的输出结果是()
BCD
CD
D
17、以下程序运行后的输出结果是( gae )
main()
{
char a[]=“Language”,b[]=“Programe”;
char *p1,*p2;
int k;
p1=a;p2=b;
for(k=0;k<8;k++)
if(*(p1+k)==*(p2+k)) 等价于 if(p1[k] == p2[k])
printf(“%c”,*(p1+k));
}
三、指针数组
1、什么是数组指针？什么是指针数组？
数组指针是一个指针来的，这个指针指向整一个数组。
指针数组是一个数组来的，这个数组的每一个成员都是指针。
2、如何定义指针数组？
定义的方法与定义普通数组一致。
1）给一个数组名 p
2）确定元素的个数，使用[]括号括住它 p[5]
3）确定每一个元素的类型 int *pa
4）将第3步的变量名去掉 int*
5）将第4步的结果写在第2步结果的前面 int* p[5] -> 指针数组
3、如何定义数组指针？
int A[5];
int (*p)[5]; = &A; --> 数组指针
练习： 提示： strlen()计算字符串实际长度
15、有以下程序
main()
{
char str[][20]={“Hello”,”Beijing”},*p=str[0];
printf(“%d ”,strlen(p+20));
}
程序运行后的输出结果是( C )
A) 0 B) 5 C) 7 D) 20
18、有以下程序
main()
{
char *p[10]={“abc”, “aabdfg”, “dcdbe”, “abbd”, “cd”};
printf(“%d ”,strlen(p[4]));
}
执行后输出结果是( A )
A) 2 B) 3 C) 4 D) 5
19、若有定义：int *p[3];，则以下叙述中正确的是( B )
A)定义了一个基类型为int的指针变量p，该变量具有3个指针。
B)定义了一个指针数组p，该数组含有3个元素，每个元素都是基类型为int的指针。
C)定义了一个名为*p的整型数组，该数组含有3个int类型元素。
D)定义了一个可指向一维数组的指针变量p，所指一维数组应具有3个int类型元素。
若有以下程序：
void main()
{
char *a[3] = {"I","love","China"};
char **ptr = a;
printf("%c %s",*(*(a+1)+1),*(ptr+1)); // 'o' "love"
}
四、const指针？
1、什么是const指针？
已经学习了非常多指针种类，例如：整型指针int*、字符指针char* -> 指的是指针的类型
const指针并不是指针的类型，只是用于修饰特定的指针类型。
2、使用场景？
一般const作用形式参数。
例子：
int fun(int a); //a=10 -> 可以随时通过a修改a本身的值。
int fun(const int a); //a=10 一旦a被初始化后，不能通过a修改a的值。
int main()
{
fun(10);
}
结论： const修改了某个变量之后，就不能通过该变量修改该变量里面的值。
3、 例子：
#include <stdio.h>
int main()
{
/* const作用于整型变量
const int a;//使用const修饰变量a，一旦变量初始化随机值之后，就不能通过a修改a的值
a = 100; //编译出错： error: assignment of read-only variable ‘a’
printf("a = %d ",a);
//a = 200; //编译出错： error: assignment of read-only variable ‘a’
//printf("a = %d ",a);
*/
/* const作用于指针变量本身
int a = 100;
int b = 50;
int * const p = &a; //const修饰p的本身，所以一旦p被初始化之后，就不能通过p修改p的本身
//p = &b; //编译出错：error: assignment of read-only variable ‘p’
*p = 200; //正确的，因为const修饰p的本身，但是没有修饰p指向的内容，所以可以通过p修改p指向的内容
printf("a = %d ",a);
*/
/* const修饰指针变量指向的内容
int a = 100;
int b = 50;
const int *p = &a; //const修饰p指向的内容，而不是修饰p
p = &b; //可以通过p修改p本身。
//*p = 200; //编译出错：error: assignment of read-only location ‘*p’
//不可以通过p修改p指向的内容。
b = 200; //可以，没有通过p修改p指向的内容
*/
return 0;
}
4、结论
int * const p; -> const修饰p的本身，一旦p被赋值了某个一个地址之后，就不能通过p修改p的地址。
int * const p = xxxx地址(正确) p = yyyy地址(错误)
-> 但是可以通过p修改p指向的内容。
*p 随便搞
const int *p; 等价 int const *p;
-> const修饰p指向的内容，p随意指向任何的地址
const int *p = xxxx地址(正确) p = yyyy地址(正确)
*p 出现错误
五、字符串函数
1、字符串在程序中如何保存使用？
char A[10] = "hello"; -> 将常量区"hello"拷贝到数组A内存空间。
char *p = "hello"; -> 将常量区"hello"首元素的地址保存在指针变量p中。
2、在linux下，有些关于字符串函数提供用户使用。
1）计算字符串实际长度 -> strlen()
2）比较两个字符串是否匹配 -> strcmp()
3）拷贝字符串到某段内存中 -> strcpy()
4）追加字符串 -> strcat()
六、计算字符串实际长度 -> 不包含' '在内 Ubuntu：man 3 strlen
NAME -> 函数的功能
strlen - calculate the length of a string -> 校对字符串长度
#include <string.h> -> 头文件
size_t strlen(const char *s); -> 函数原型
s： 需要计算的字符串的首元素的地址
返回值：字符的个数。
例子：
#include <stdio.h>
#include <string.h>
int main()
{
char A[100] = "helloworld";
char *p = "helloworld";
printf("sizeof(A) = %d ",sizeof(A));//100
printf("sizeof(p) = %d ",sizeof(p));//4
printf("strlen(A) = %d ",strlen(A));//10
printf("strlen(p) = %d ",strlen(p));//10
return 0;
}
结论： sizeof()计算空间大小，strlen()计算字符串的长度。
七、比较两个字符串是否匹配 -> strcmp()
1、与整型变量是否相等比较
int a = 200;
int b = 100;
if(a == b) -> 整型数据使用"=="来进行判断
2、比较两个字符串能不能用"=="?
char A[100] = "helloworld";
char *p = "helloworld";
if(A == p) -> 不可以，只能判断两个地址是否相等，这样对比是没有任何意义，只有对比内容才有意义。
3、 如何比较两个字符串？ -> 只能使用strcmp() -> man 3 strcmp
NAME
strcmp, strncmp - compare two strings 比较两个字符串
#include <string.h>
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
s1：需要进行比较的字符串1的地址
s2：需要进行比较的字符串2的地址
n： 只匹配前n个字节
返回值：
s1与s2匹配 -> 0
s1与s2不匹配 -> 非0
4、例子：
#include <stdio.h>
#include <string.h>
int main()
{
int ret;
char A[100] = "helloworld";
char *p = "hello";
ret = strncmp(A,p);
if(ret == 0)
{
printf("match! ");
}
else{
printf("no match! ");
}
return 0;
}
练习：有一张银行卡，密码是gec123456,请求用户输入密码，如果密码正确，则输出密码的长度，如果密码错误，则重新输入！如果输入的次数超过5次，则程序直接退出。
#include <stdio.h>
#include <string.h>
int main(int argc,char *argv[])
{
char passwd[20] = "gec123456"; //银行卡密码
char input_passwd[20] = {0}; //清空数组
char *p = input_passwd;
int count = 0;
while(count < 5)
{
scanf("%s",p);
if(strcmp(passwd,p) == 0)
{
printf("passwd length = %d ",strlen(passwd));
break;
}
else{
count++;
continue;
}
}
return 0;
}
八、拷贝字符串到某段内存中 -> strcpy()
char A[10] = "hello";
char A[10] = {"hello"};
char A[10] = {'h','e','l','l','o'};
char A[10]; -> 如果定义没有初始化，则以后都不能整体初始化。
A[0] = 'h';
...
strcpy() -> 如果定义没有初始化，则以后还能使用strcpy()整体初始化。 -> man 3 strcpy
char A[10];
A = "hello" //错误
strcpy(A,"hello"); //正确
NAME
strcpy, strncpy - copy a string
SYNOPSIS
#include <string.h>
char *strcpy(char *dest, const char *src);
char *strncpy(char *dest, const char *src, size_t n);
dest：需要把字符串拷贝到的空间的起始地址，这个空间必须足够大。
src：需要拷贝的字符串的地址。
n: 只拷贝src前n个字节
返回值：
成功： 返回指向dest内存空间的地址
失败： NULL
#include <stdio.h>
#include <string.h>
int main()
{
char A[11] = "helloworld";
char *p = "abc";
int i;
for(i=0;i<11;i++)
{
printf("A[%d] = %c ",i,A[i]);
}
strcpy(A,p);
for(i=0;i<11;i++)
{
printf("A[%d] = %c ",i,A[i]);
}
printf("A = %s ",A);
return 0;
}