深入理解C指针之五：指针和字符串

　　基础概念

　　字符串可以分配到内存的不同区域，通常使用指针来支持字符串操作。字符串是以ASCII字符NUL结尾的字符序列。ASCII字符NUL表示为\0。字符串通常存储在数组或者从堆上分配的内存中。不过，并非所有的字符数组都是字符串。例如，字符数组可能没有NUL字符。

　　C中有两种类型的字符串。

　　*　单字节字符串。由char数据类型组成的序列。

　　*　宽字符串。由wchar_t数据类型组成的序列。

　　wchar_t数据类型用来表示宽字符串，可能是16位或32位宽。这两种字符串都以NUL结尾。宽字符主要用来支持非拉丁字符集，对于支持外语的应用程序很有用。

　　字符串的长度是除了NUL字符之外的字符数。为字符串分配内存时，要记得为NUL字符预留空间。注意NUL是一个字符，定义为\0，与NULL(void*(0))不一样。NULL用来表示一种特殊的指针。

　　字符常量是单引号引起来的字符序列。字符常量通常由一个字符组成，也可以包含多个字符，如转义字符。在C中，它们的类型是int。char的长度是1字节，而一个字符字面量的长度是 sizeof(int) 个字节。

printf("%d\n", sizeof('a'));//4

 　　声明字符串的方式有3种：字面量、字符数组、字符指针。字符串字面量是用双引号引起来的字符序列，常用来进行初始化，它们位于字符串字面量池中。如果声明一个拥有32个字符的数组，那么只能放31个字符串文本，因为字符串要以NUL结尾。字符串在内存中的位置取决于声明的位置。

　　定义字面量时通常会将其分配在字面量池中，多次用到同一个字面量时，池中通常只有一份副本。通常认为字面量是不可变的。你可以关闭字面量池来生成多个副本。在哪里使用字符串字面量不重要，它没有作用域的概念。

　　有些编译器允许修改字符串，因此把不希望被修改的字符串声明为常量是个不错的选择。

　　字符串初始化方式取决于变量被声明为数组还是指针，字符串所用的内存要么是数组要么是指针指向的一块内存。我们可以从字符串字面量或其它地方（比如标准输入）得到字符。

char head[] = "hello man";

printf("size of head is : %d\n",sizeof(head));

//size of head is : 10

 　　可以看到 "hello man"有9个字符，但是长度是10，因为有NUL字符。还可以strcpy函数初始化数组。

char head1[10];

strcpy(head1,"hello man");

 　　注意不要用数组的名字作为左值。

　　动态内存分配可以提供更多灵活性，也可能让内存存在更久。通常使用malloc和strcpy来初始化字符串。

char* head2 = (char*) malloc (strlen("hello man")+1);

strcpy(head2,"hello man");

  　　注意在使用malloc决定所需内存长度时，要为NUL预留空间，并且使用strlen而不是sizeof。sizeof会返回数组和指针的长度，而不是字符串的长度。如果用字符串字面量来初始化指针会导致指针指向字符串字面量池。注意不要把字符字面量赋给指针，因为它是int类型。可以把字符字面量赋给解引后的指针。

*(head2 + 7) = 'e';

printf("head2 is %s\n", head2);

//head2 is hello men

 　　总之字符串可能位于全局或静态内存（global or static array），也可能位于字符串字面量池（{……}），可能位于堆上（malloc），可能位于函数的栈帧里（char array[]）。字符串的位置决定它能存在多久以及哪些程序可以访问它。全局内存的字符串会一直存在，可以被多个函数访问；静态字符串也一直存在，但只有定义它的函数能访问；堆上的字符串可以被多个函数访问，直到被释放前都存在。

　　标准字符串操作

 　　比较字符串的标准方法是strcmp函数。其原型如下。

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

 　　如果两个字符串相等，返回0。s1大于s2，返回正数。s1小于s2，返回负数。

char command[16];

printf("enter a command :");

scanf("%s",command);

if(strcmp(command,"quit")==0)
{

        printf("you typed quit!\n");

}

else

{

        printf("i don't know what you typed!\n");

}

 　　注意如果此处使用if(command == "quit")的话，被比较的实际是command的地址和字符串字面量的地址。

　　复制字符串通常使用strcpy函数实现，其原型如下：

char* strcpy(char* s1, const char* s2);

 　　有一类应用程序会读入一系列字符串，挨个存入占最少内存的数组。先创建一个足够长的字符串数组，其长度足以容纳用户允许输入的最长字符串，然后把字符串读入这个数组。有了读取的字符串，我们就能根据字符串的长度分配合适的内存。

char mynames[32];

char* myname[30];

size_t count = 0;



printf("enter a name please:");

scanf("%s",mynames);

myname[count] = (char*) malloc (strlen(mynames)+1);

strcpy(myname[count], mynames);

count++;

  　  可以在一个循环里重复这个操作。

　　两个指针可以引用同一个字符串。两个指针引用同一个地址称为别名。把一个指针赋值给另一个指针只是复制了字符串的地址而已。

　　字符串拼接涉及两个字符串的合并。通常用strcat来执行这种操作。这个函数的原型为：

char* strcat(char* s1, const char* s2);

 　　下面是如何使用缓冲区拼接字符串。

char* error = "ERROR: ";

char* errormsg = "not enough memory!";

char* _buffer = (char*) malloc (strlen(error) + strlen(errormsg) +1);

strcpy(_buffer, error);

strcpy(_buffer, errormsg);

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

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

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

　　如果直接使用strcpy(error, errormsg)的话，可能会覆盖error字符串字面量地址后面某些未知的内容，因为我们没有为新的字符串分配独立内存。拼接字符串常见的错误就是没有为新字符串额外分配空间。此外注意不要使用字符字面量代替字符串字面量作为该函数的参数。

　　传递和返回字符串 　　

　　 先定义一个函数。

size_t strLength(char* string){

size_t length = 0;

while(*(string++)){

length++;

}

return length;

}



char simpleArray[] = "simple string";

char* simplePtr = (char*) malloc (strlen("simple string")+1);

strcpy(simplePtr, "simple string");



printf("%d\n", strLength(simplePtr));//13

 　　对指针调用这个函数，只需要传入指针的名字。对数组使用该函数也可以这么做。在这里数组的名字被解释成了地址。

printf("%d\n", strLength(simpleArray)); 

 　　你也可以对数组的0下标使用取地址操作符，但是那样太繁琐了：strLength(&simpleArray[0])。

　　把参数声明为指向字符常量的指针，可以防止字符串被修改。假如要让函数返回一个由该函数初始化的字符串，必须决定是否由函数调用者负责释放分配的内存。如果在函数内部动态分配内存并返回指向该内存的指针，那么调用者必须负责最终释放该内存，这要求调用者必须清楚函数的使用方法。

　　main函数通常是应用程序第一个执行的函数。对基于命令行的程序来说，通过为其传递某些信息来打开某些功能的开关很常见。比如linux下的ls命令会通过接受 -la 等参数来执行不同行为。C通过argc和argv参数支持命令行参数。第一个参数argc是一个整数，用来指定传递参数的数量。系统至少会传递一个参数，这个参数是可执行文件的名字。第二个参数argv，通常被看做字符串指针的一维数组，每个指针引用一个命令行参数。

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

int i =0;

while(i<argc){

printf("argv[%d]is %s\n",i,argv[i]);//argv[0]is ./mysender

i++;

}

}

　　可以看到，不附加任何参数，默认自带的一个参数就是 ./mysender，是我的编译后文件的名字。试试用以下方式执行：./mysender -f jack -la limit = 100，此时输出为：

argv[0]is ./mysender

argv[1]is -f

argv[2]is jack

argv[3]is -la

argv[4]is limit

argv[5]is =

argv[6]is 100

 　　由于我把 "=" 符号用空格分开了，结果 "=" 被当做一个参数了。实际上应该用空格把每个参数分开，参数本身不应包含空格了。

　　函数返回字符串时，返回的实际是字符串的地址。这可能是字符串字面量的地址，可能是动态内存的地址，可能是本地字符串变量的地址。

　　先看第一种情况。对于静态的指向字符串字面量的指针，应该注意在不同地方重复使用会覆盖上一次的结果。字符串并非总是被看做常量，可以通过命令关闭字符串常量池，把字符串声明为常量可以防止字符串被修改。如果返回的是动态分配的内存，那么一定要注意防止内存泄露。返回局部变量字符串的地址可能有问题，因为函数执行完毕后该处内存可能被别的栈帧覆写。比如你在函数里声明一个字符串数组并初始化了，然后返回数组的地址，这个数组所占用的内存是不安全的，面临被其它函数的栈帧覆写的风险。

　　函数指针和字符串　　

　　 通过函数指针控制程序执行是一种非常灵活的方法。

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



char* stringToLower(const char* string){

char* tmp = (char*) malloc (strlen(string) + 1);

char* start = tmp;

while(*string != 0){

*(tmp++) = tolower(*(string++));

}

*tmp = 0;

return start;

}



main(){

typedef int (fptroperation)(const char*, const char*);

int compare(const char* s1, const char* s2){

return strcmp(s1,s2);

}



int compareIgnoreCase(const char* s1, const char* s2){

char* t1 =stringToLower(s1);

char* t2 =stringToLower(s2);

int result = strcmp(t1,t2);



free(t1);

free(t2);



return result;

}

void sort(char* array[], int size, fptroperation operation){

int swap = 1;

while(swap){

swap = 0;

int l = 0;

while(l<size-1){

if(operation(array[l],array[l+1])>0)

{

swap = 1;

char* tmp = array[l];

array[l] = array[l+1];

array[l+1] = tmp;

}

l++;

}

}

}

void display(char* names[], int size){

int i = 0;

while(i<size){

printf("%s ",names[i]);

i++;

}

printf("\n");

}

char* names[] = {"jack","rose","Titanic","hello","World"};

char* newnames[] = {"jack","rose","Titanic","hello","World"};

sort(names, 5, compare);

display(names,5);//Titanic World hello jack rose 

sort(newnames, 5, compareIgnoreCase);

display(newnames, 5);//hello jack rose Titanic World

}

  　　这个示例通过使用函数指针来实现不同规则下的字符串比较工作。