C第九天

第九课 指针与字符串

一、指针

1....

2....

3.指针的用法

2)指针也可以作为函数的返回值，但是不要返回指向局部变量的指针。因为函数返回以后，其局部变量所占用的内存将随函数栈一起被释放，所得到的指针为野指针。可以返回全局变量、静态局部变量、实参变量以及成员变量的指针。因为这些变量在函数返回以后依然有效。

int foo (void) {

return 10;

}

a = foo ();

int* foo (void) {

...

return p;

}

int* foo (void); // 函数声明，声明一个没有参数，返回int*的foo反函数

int (*foo) (void); // 函数指针

void foo (void) {

}

没有返回值的函数。

4.指针计算

1)一个指针型数据可以和一个整数做加减法计算，表示地址计算。所得结果与指针的类型有关。

int型指针+1：地址+4

short型指针+1：地址+2

char型指针+1：地址+1

...

X型指针+/-N：地址+/-N*sizeof(X)

2)通过指针计算可以访问数组中的元素。所谓的下标运算“[]”，其本质就是指针计算。

3)相同类型的指针之间可以做减法运算，所得为两个指针之间的距离，以指针类型为单位。

5.数组和指针

1)数组名就是数组的首地址，即首元素的地址，其本质就是一个指针，但其类型为常量。

2)以数组为参数的函数，所传递的实参是数组的首地址，而形参就是数组元素类型的指针。

6.常量、常量指针和指针常量

1)const可以修饰普通变量，该变量就会被当做常量来处理，即其值一经初始化就再不能被修改。

2)常量指针：指向常量的指针,即无法通过该指针修改其目标。

const int* p;

int const* p;

3)指针常量：指针型的常量，即无法修改其值的指针。

int* const p;

const int* const p; // 常量指针常量，p本身不能改，其目标亦不能改

二、字符串

1.在C语言中没有专门的字符串类型，通常情况下，字符串可以用三种方式表示：

1)字面值方式："hello world"。不能修改，但是可以被赋值给变量，并在变量中修改。字面值方式的字符串后面自动追加'\0'结束符。字面值可以拼接：

"hello ""world"

" tarean" ==> "hello world tarena"

2)字符数组方式：char str[] = {...};以char型数组表示字符串，注意结尾符'\0'，必须手动加入数组中。

3)字符指针方式：char* psz = ...;可以指向字面值字符串，也可以指向字符数组字符串。同样有效字符串必须以'\0'结尾。

char str[] = "abcdefg";

str[1] = '1';

*(str+2) = '2';

str[4] = 0; // = '\0';

printf ("%s\n", str);

输出：a12d

str[4] = '0';

printf ("%s\n", str);

输出：a12d0fg

-------------

char str1[] = "ABC";

char str2[] = {'A','B','C'};

sizeof (str1)>sizeof (str2)

-------------

int a;

scanf ("%d", &a);

printf ("%d", a);

char str[128];

scanf ("%s", str);

2.字符串I/O函数

char* psz;

scanf ("%s", psz); // 错误！

char* gets (char* str);

从标准输入读取字符串保存到str所指向的内存中，直到遇到\n为止，并将\n转换为\0。返回str。

int puts (char* str);

向标准输出打印str所指向的字符串，并将\0转换为\n。成功返回非0，失败返回0。

3.其它字符串常用函数

string.h

size_t strlen (char* str);

返回str的长度。

char* strcpy (char* to, const char* from);

将from所指向的字符串拷贝到to所指向的内存中。返回to。

char* strcat (char* str1, const char* str2);

将str2所指向的字符串连接到str1所指向字符串的末尾。返回str1。

使用strcpy/strcat的时候，to/str1所指向的内存空间一定要足够大，否则会导致内存溢出。

int strcmp (const char* str1, const char* str2);

str1 < str2：返回值小于0

str1 = str2：返回值等于0

str1 > str2：返回值大于0

4.字符串数组

1)二维数组

char sa[][128] = {"beijing", "tianjin", "shanghai", "chongqing"};

printf ("%s\n", sa[0]);

// beijing

2)字符指针数组

数组首地址：数组首元素的地址，数组名。

指针数组：数组中的每个元素都是指针。

int a, b, c;

int* pa[] = {&a, &b, &c};

char* ps[] = {"hello", "world", "mw"};

练习：基于命令行的简单计算器，实现两个整型操作数的+-x/%运算。

提示：atoi()将字符串转换整数。

练习：实现字符串合并函数：

void merge (const char* p1, const char* p2, char* p3);

将p1与p2合并放入p3，p1和p2以排好序，要求p3也是有序的。

p1 : agkxz

p2 : bhmp

p3 : abghkmpxz

#include <stdio.h>

void print (/*int arr[]*/int* arr, int len) {

int i;

for (i = 0; i < len; i++)

printf ("%d ", arr[i]);

printf ("\n");

}

int main (void) {

int a[] = {1,2,3,4,5};

printf ("%p\n", a);

printf ("%p\n", &a[0]);

int* p = a, i;

for (i = 0; i < 5; i++)

printf ("%d ", p[i]/* *(p+i) */);

printf ("\n");

int b[] = {10,20,30,40,50};

p = b;

for (i = 0; i < 5; i++)

printf ("%d ", p[i]);

printf ("\n");

// a = b; // 编译错误

print (a, sizeof (a) / sizeof (a[0]));

return 0;

}

#include <stdio.h>

#include <string.h>

int main (int argc, char* argv[]) {

if (argc < 4)

goto error;

if (strspn (argv[1], "0123456789") != strlen (argv[1]) || strspn (argv[3], "0123456789") != strlen (argv[3]))

goto error;

int a = atoi (argv[1]);

int b = atoi (argv[3]);

int c;

if (! strcmp (argv[2], "+"))

c = a + b;

else

if (! strcmp (argv[2], "-"))

c = a - b;

else

if (! strcmp (argv[2], "x"))

c = a * b;

else

if (! strcmp (argv[2], "/"))

c = a / b;

else

if (! strcmp (argv[2], "%"))

c = a % b;

else

goto error;

printf ("%s %s %s = %d\n", argv[1], argv[2], argv[3], c);

return 0;

error:

printf ("使用方法：%s a +|-|x|/|%% b\n", argv[0]);

return -1;

}

#include <stdio.h>

int main (int argc, char* argv[]) {

printf ("argc=%d\n", argc);

int i;

for (i = 0; i < argc; i++)

printf ("argv[%d]=%s\n", i, argv[i]);

return 0;

}

#include <stdio.h>

void show (const int* pn) {

printf ("show: %d\n", *pn);

//(*pn)++; // 编译错误

}

int main (void) {

const int a = 100;

// a = 200;

// a++;

// a -= 10;

int b = 100;

const int* cp = &b; // 常量指针

// *cp = 200; // 编译错误

int* const pc = &b; // 指针常量

int c = 300;

// pc = &c; // 编译错误

cp = &c; // ok

*pc = 400; // ok

show (&b);

printf ("after show: b=%d\n", b);

return 0;

}

#include <stdio.h>

#include <string.h>

void reverse (char* str) {

int len = strlen (str), i;

for (i = 0; i < len / 2; i++) {

char c = str[i];

str[i] = str[len-1-i];

str[len-1-i] = c;

}

}

int main (void) {

char str[1024];

for (;;) {

gets (str);

reverse (str);

puts (str);

}

return 0;

}

#include <stdio.h>

void merge (const char* p1, const char* p2, char* p3) {

int i = 0;

for (;;)

if (*p1 && *p2)

if (*p1 < *p2)

p3[i++] = *p1++;

else

p3[i++] = *p2++;

else if (*p1)

p3[i++] = *p1++;

else if (*p2)

p3[i++] = *p2++;

else

break;

p3[i] = '\0';

}

int main (void) {

const char* s1 = "adgkm";

const char* s2 = "behklop";

char s3[256];

merge (s1, s2, s3);

printf ("%s + %s = %s\n", s1, s2, s3);

return 0;

}

#include <stdio.h>

int main (void) {

char* pc = NULL;

printf ("pc=%u\n", pc);

printf ("pc+1=%u\n", pc+1);

pc += 2;

pc++;

printf ("pc=%u\n", pc); // 3

int* pn = NULL;

printf ("pn=%u\n", pn);

printf ("pn+1=%u\n", pn+1);

pn += 2;

pn++;

printf ("pn=%u\n", pn); // 12

int arr[] = {100,200};

int* p = arr;

printf ("*p=%d\n", *p); // 100

p++;

printf ("*p=%d\n", *p); // 200

printf ("%d\n", arr[1]); // 200

printf ("%d\n", *(arr+1)); // 200

printf ("%d\n", *(1+arr)); // 200

printf ("%d\n", 1[arr]); // 200

// x[y] ==> *(x+y)

int* p1 = NULL;

int* p2 = p1 + 10;

printf ("p2=%u\n", p2); // 40

printf ("p2-p1=%d\n", p2 - p1); // 10

//printf ("p2+p1=%d\n", p2 + p1); // 编译错

return 0;

}

#include <stdio.h>

int g = 100;

int* foo (/*void*/int* p) {

static int a = 100;

//return &a;

//return &g;

return p;

}

int* bar (void) {

int b = 200;

return &b;

}

int hum (void) {

int c = 300;

return c;

}

int main (void) {

int a = 100;

int* p = foo (&a);

bar ();

printf ("%d\n", *p);

printf ("%d\n", hum ());

return 0;

}

#include <stdio.h>

int main (void) {

char sa[][128] = {"beijing", "tianjin", "shanghai", "chongqing", "达内科技"};

size_t i;

for (i = 0; i < sizeof (sa) / sizeof (sa[0]); i++)

printf ("%s\n", sa[i]);

char* ps[] = {"hello", "world", "mw"};

for (i = 0; i < sizeof (ps) / sizeof (ps[0]); i++)

printf ("%s\n", ps[i]);

return 0;

}

#include <stdio.h>

#include <string.h>

int main (void) {

char str[1024] = {0};

printf ("%d\n", strlen (str));

strcpy (str, "hello");

printf ("%s\n", str);

printf ("%s\n", strcpy (str, "good"));

printf ("%d\n", strlen (strcat (str, " morning")));

printf ("%s\n", str);

printf ("%d\n", strcmp ("abc", "abc"));

printf ("%d\n", strcmp ("abc", "aBc"));

printf ("%d\n", strcmp ("abC", "abc"));

printf ("%d\n", strcmp ("abc", "abcd"));

return 0;

}

#include <stdio.h>

int main (void) {

printf ("hello "

"world\n");

char str[] = {'h','e','l','l','o',' ','w','o','r','l','d','\n','\0'};

printf ("%s", str);

char str2[] = "hello world\n";

str2[0] = 'H';

printf ("%s", str2);

char* psz = "hello world\n";

//psz[0] = 'H'; //*(psz+0)='H', 段错误

printf ("%s", psz);

psz = str2;

psz[1] = 'E'; // *(psz+1)='E'

printf ("%s", psz);

return 0;

}