在C语言中，对于字符串有这样一个问题
 
数组定义的字符串
 
char a[]="abcdefg"
 
和指针定义的字符串
 
char *b="abcdefg"
 
从表面上来看是一样的，a是一个数组指针，好像和b等价，其实不是这样的，区别可以从下面这个程序看出
 
//情况1
char a[]="abcdefg";
*a='1';
//情况2
char *b="abcdefg";
*b='1';
 
其中情况1是可以实现的，但是情况2却是会报内存溢出的错误，原因是虽然都是定义一串字符串，但是数组定义的字符串中每一个元素都是可读可写的，但是指针定义的字符串是存放在静态变量区的，不能对单个元素进行更改，只能读不能改。所以下面这种情况是允许的：
 
char *b="abcdefg";
cout<<*(b+2);
 
但是指针字符串可以实现b=a的操作，相当于把b指针指向a字符串的地址

 #include <stdio.h>
 #include<stdlib.h>

int main()
{
   char *s = "abcde";
   char s1[] = "ffffff";
   //*s = *s1; //错误，s指向的字符串是存放在不可以更改的内存区域，更改s指向单元的任何数据都是不允许的。
   
   s++;
  // s1++;//错误，表达式必须是可修改的左值
  // s1 = s1 +2;
   printf("%s\n",s);//输出结果为  bcde
   printf("%s\n",s1);
   printf("%s\n",s1+2);//输出结果为 ffff
   getchar();
   return 0;

}

 
 

 
 
char *s = "abcde"，说明申请的空间的内容是不能更改的，可以改为 char s[ ];
 
 因为s指向的字符串是存放在不可以更改的内存区域，更改s指向单元的任何数据都是不允许的。所以*s = *s1是重写s所指单元，故出现错误。数组是可以的，因为它不是存放在不可以更改的内存区域。
 
 但为何指针指向的字符串常量不可更改，而用字符串常量初始化的数组就可以更改？
 
 因为写编译器的人规定了指针指向的字符串常量是存放在不可以更改的内存区域的。编译器的游戏规则是这样的。数组没有这么样的规则。
 
 

 
 

 
 
转自：
 
 点击打开链接
 
 在C中定义字符串有下列几种形式：字符串常量，char数组，char指针
 
 1.字符串常量
 
         即：位于一对双括号中的任何字符。双引号里的字符加上编译器自动提供的结束标志\0字符，作为一个字符串存储在内存中。如：printf("%s","hello"); //"hello"
        如果字符串文字中间没有间隔或间隔的是空格符，ANSI  C 会将其串联起来。例：
          char greeting[50] = "hello,and" "how are" "you";
        等价于：
          char greeting[50] = "hello,and how are you";
        字符串常量属于静态存储类。静态存储是指如果在一个函数中使用字符串常量，即使是多次调用了这个函数，该字符串在程序的整个运行过程中只存储一份。整个引号的内 容作为指向该字符串存储位置的指针。这一点与把数组名作为指向数组存储位置的指针类似。
 
 2.字符串数组及其初始化
 
        初始化例子：
        char m[40] = "hello,world";  //定义字符串数组时必须指定数组大小（整型常量），在指定大小时，要确保数组的大小比预定的大一个，因为编译器会自动添加'\0'。
                                                         //多余的元素会初始化为'\0'
        char m={'h','e','l','\0'};  //注意标志结束的空字符，若没有它，得到的只是一个字符数组而不是字符串
 
 3.利用char指针定义字符串
 
        char *m = "hello,world"; //自动添加'\0'
        注意：此时字符串指针m指向字符串常量,不成用*(m+1)='o'修改此常量，因为这个字符串常量放在常量区不能被修改
 
 4.数组和指针
 
        数组形式和指针形式有什么不同呢？
        数组形式： char m[40] = "hello,world"; 
        指针形式： char *m = "hello,world";
 
    数组形式：
 
          编译器会把数组名m看作是数组首元素的地址&m[0]的同义词，m是个地址常量。可以用m+1来标识数组里的下一个元素，但不能使用++m，增量运算符只能在变量前使用， 而不能在常量前使用。
          m[40]在计算机内存中被分配一个有40个元素的数组（其中每个元素对应一个字符，还有一个附加的元素对应结束的空字符'\0'）。每个元素都被初始化为相应的字符。  
         通常，被引用的字符串存储在可执行文件的数据段部分；当程序被加载到内存中时，字符串也被加载到内存中，把被引用的字符串复制到数组中
 
 
    指针形式：
 
          指针形式（*m）也会在静态存储区为字符串预留空间。此外，一旦程序开始执行，还要为指针变量m另外预留一个存储位置，以在该指针变量中能够存储字符串的地址。
           m指向字符串的第一个字符，可用++m指向第二个字符。  指针m是个变量。   
 
 
 

 
 
如果我们用动态申请的方法给一个字符串赋值，那么该字符串在程序运行过程中的值依然可以修改。
 

#include<stdio.h>
#include<stdlib.h>

int main()
{
  int a,b;
  char *c = "akbiee";
  char *m = (char*)malloc(sizeof(char)*6);
  while(*c)
    *m++ = *c++;
  *m = '\0';
  m = m-6;
  *(m+2) = 'w';//正确，可以修改
  //*(c+2) = 'f';//错误，不能修改

  printf("%s\n",m);
  system("pause");
  return 0;
 

}

 

 

 字符数组：存储字符的数组
 
 字符串 ：是使用最频繁的字符数组，是一个特殊的字符数组
 
 C++中并没有专门的字符串的类型，一个字符串实际上就是一个字符数组，与普通字符数组不同的是，字符串的结尾有一个字符\0,表示字符串的结束。
 
 char 可以定义字符数组，也可以定义字符串
 
 char 定义的字符数组
 
char b[]={'h','e','l','l','o'};//生命字符数组，长度为5
 
1
 
 char定义字符串
 
 字符串的优势在于输入、输出和赋初值，输入输出不需要使用循坏。字符数组需要用循环依次输出每个字符。
 
 char b[]="hello";//定义字符串
 char *p = b;
 cout << b;//输出的是hello
 cout<<  *p;//指针指向首地址，所以输出为 h
 
1
2
3
4
 
 字符数组和字符串的区别
 
 C++中，字符数组和字符串都是通过char关键字来定义的，但二者不同，显著的区别就是字符串的长度是字符数目加1，因为包含了\0结束符，而字符数组的长度就是字符的数目。对于字符数组可以通过sizeof求出其长度，但是对于字符串是其长度加上1。因此这个长度没有意义，为此C++可以用strlen求出字符串的有效内容的长度（不含字符串结束标识\0）。
 
 指针与字符串、指针与字符数组
 
 指针指向字符数组
 
    char b[] = { 'h','e','l','l','o' };
    char *pchar = b;
    cout << *pchar;//该语句输出 h
    //cout << b; //不要用这个方式输出，输出的是 hello加一些乱码字
    cout << b[0]; //该语句输出 h
 
1
2
3
4
5
 
//以下语句实现用指针输出hello。
for (size_t i = 0; i < 5; i++)
    {
        cout << *pchar;
        pchar++;
    }

 
1
2
3
4
5
6
7
 
 指针指向字符串
 
 char定义的字符串
 
 用char定义一个指针，并指向了char定义的字符串，那么用指针变量p 和*p输出的结果不一样，请看一下两种情况。 具体原因我也不知道。
 
 方式1
 
  char str[] = "we are poor students";//这是一个字符串
  cout<<str<<endl;//输出的是：we are poor students。这也是字符串的优点，可以整个输出。

  //指针访问每个字符并输出。
  char *p = str;
  while (*p != '\0')
  {
    cout << *p;
    p++;
  } 
 
1
2
3
4
5
6
7
8
9
10
 
 方式二
 
    //
    char *p = str;
    while (*p != '\0')
    {
        cout << p<<endl;
        p++;
    }
以上语句输出的结果是：
    we are poor students
    we are poor students
    e are poor students
     are poor students
    are poor students
    re poor students
    e poor students
     poor students
    poor students
    oor students
    or students
    r students
     students
    students
    tudents
    udents
    dents
    ents
    nts
    ts
    s
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 string定义的字符串
 
 这里需要特别注意的是string并不是一个关键字，而是一个类。 
 下面代码的指针指向的是对象，而不是string中的第一个字符。
 
    string str="hello world";
    string *p1 = &str; //注意必须加取地址运算符 &
    cout << str << "," << *p1; //输出的是  hello world,hello world
 
1
2
3
 
如果想访问string定义字符串中的每个字符，可以使用 str[i]
cout<<p1[0];//输出的是 hello world
不可像char定义的字符串那样使用p1[i],在string中，i>0并未分配指针，这种理解方式本来就错误。
 
 用指针遍历 每个字符
 
用C++的迭代器
 
  string str1 = "we are poor students"; 
  for (string::iterator p1 = str1.begin(); p1 !=str1.end(); p1++)
  {
    cout << *p1 ;
  }
 
1
2
3
4
5
 
用c_str() （Get C string equivalent）函数转化为c类型的string,如下代码所示：
 
string str1 = "we are poor students";
const char *p = str1.c_str();//这句是关键。
for (size_t i = 0; i < str1.size(); i++)
{
  cout << *(p + i);
}

c/c++中使用字符串的频率还是比较高的，下面就字符串的不同定义及其使用方法做一些对比
 
 
 
字符串一般有以下三种定义方法：
 
1、char *p="hello";
 
2、char str[6]="hello";
 
3、string s="hello";
 
【第一种字符串】：这种定义方式会被编译器默认为字符串常量，自行默认为是不会被改变的，所以编译时会被存储在一个只读的数据段中，尝试对这种类型字符串的改变是不被允许的。
 
如：
 
 
 
char *p="hello";
p[1]='x';
 
 
这个时候，输出字符串就会爆出"段错误"(我这里的实验平台是linux，会和windows有所不同)，因为修改了内存只读区域，这是不允许的；
 
【第二种和第三种字符串】：这种定义方式实际上是把存在只读数据段中的字符串复制到了一个字符数组中，这种字符串中的任意字符都可以被随便改变，这里不再做出演示。
 
*注意一下情况：
 
 
 
char *str1="hello";
char *str2="hello";
 
 
这个时候，str1和str2指向的其实是同一个内存地址，可以用一下语句进行验证：
 
 
 
if(str1==str2)
        cout<<"str1=str2"<<endl;
 
 
 *linux下定义字符串爆出warning的处理方法：在定义字符串时加上const限定修饰符，告诉编译器这是常量，否则g++/gcc都会认为是变量，所以会爆出warning