string、char*、char[]和const char*辨析

要理解char*、char[20]和const char*之间的关系，不妨把char替换为int方便理解

第一步，先理解指针

懂得指针的跳至第二步

int *a;
char *ch;

两者都是指针变量，a和ch的值都是地址，指向int和char类型
如果我要使用a或者ch，必须把其他变量的地址传给它。

int main()
{
	int m = 1000;   char c = 'p';
	int* a;        char* ch;
	a = &m;        ch = &c;
	printf("%d    %c",*a,*ch);
}
输出： 1000     p

可以注意到，要传给a的必须是地址，而数组int array[3] = {1,2,3}中的array也是地址，所以我们可以

int main() {
	int array[3] = {1,2,3};
	int *a=array;
	printf("%d", *a); 
	return 0;
}
输出array[0]，也就是1

或者

int main()
{
	char c[4] = "abc";
	char* ch;
	ch = c;
	printf("%c\n%s",*ch, c);
}
输出:
a
abc
注意：字符数组最后一个为‘\0'

综上所述：指针存储一个地址，就是它的指向，该地址对应一个内容。
此外：int*a=&m这种写法只能在定义指针的时候写，否则是错的

第二步，理解const

懂得const的跳至第三步
const

const int a;
a是常量，a值不可更改
若使用：
    const int a = 3;
	const char ch = 'p';
	a = 4;
	ch = 'q';
IDE则提示：表达式左侧必须是可修改的左值

接下来是const int*

const int *a;
指针表示它的值是一个地址，指向一个int类型；
const表示它的指向（int常量或变量）不可更改

这是对的吗？答案是否定的，因为const修饰的是整型数 int，而不是指针。
整型数 *a是不可以修改的，而指针却是可以修改的，可以重新指向另外一个地址。
总而言之，解引用是不可取的。
是不是理解有点困难，让我们来看一个例子

int a1=1; int a2=2;
const int *a；
a=&a1;              //此时输出*a，结果为1
a=&a2;               //修改a的指向为a2，结果为2
a2=3;               // 修改a所指向的变量a2的值
printf("%d",*a);   //此时输出*a，结果为3
*a=3来直接赋值       //出错，因为*a被const修饰，不能更改内容

const char*

首先，const char*和char*类似于string可以直接表示字符串
int main()
{
	const char* c = "123";
	string str = "456";
	printf("%s ", c);
	cout<<str;//也可用printf("%s",str.c_str());
	printf("\n%c %c", c[0], str[0]);
}
输出123 456
1 4

在一定程度上，可以视此时的c和str都为字符串
但是，如果我们使用

char* ch = "123"

则提示错误，提示const char*不能初始化char*类型。怎么会这样呢，我不是刚才说char*也可以表示字符串吗，实际上是vs这个IDE的原因，可以参照
https://blog.youkuaiyun.com/yx171532/article/details/104569926/
接着上面

const char* c = "123"
string str = "456";
c[1] = '3'; // 不能更改指针指向的内容，会报错
str[1]='9';// string类型可以更改
c = "456"; // 可以更改指针的指向，不会报错

可见，const char * 只是说指针指向的内容不可变，但指针本身可以再赋值
但是c=str会报错，提示不存在string到const char*的适当转换函数(如何转换见后文)

综上所述，const char(或int) a可以修改指针的指向，不可以修改指针所指的内容。
比如说strcpy函数的第一个参数就不能是const char”类型，因为无法修改。

*此外，int const a等与本篇关系有点远，请读者自行了解
https://blog.youkuaiyun.com/qq_37941471/article/details/80678904

第三步,四者区分

结论1：char[]和string可读写，const char*不可写(更改)
（注：此处不考虑char* str = new char[20]；）
char是否可读写要看初始化的方式。如果用char[]初始化，那么它指向栈区，内容可修改，如果用"123"这种const char类型初始化，那么它指向常量区，内容不可以被修改。但是地址（它们的指向）是都可以被修改的。

int main()
 {
      char *a = "abc";
      char b[3] = { 'a','b' };
      b[0] = 'b';
      a[0] = 'b';
      cout << a << " " << b ;
 }

以上代码在运行时时会出错，因为const char*和char[]的内存分区是不同的。
上面代码中的char*a = "abc"的"abc"是常量所以被分配在常量存储区，a为字符指针类型是存放在栈区可以被更改，而常量存储区是不能更改的，是只读区域，所以当你试图去写入数据的时候，会报错。
而char b[3] = {‘a’，‘b’}的字符a和b是存放在栈区的所以可以进行写操作。

    char str1[] = "abc";
	char str2[] = "abc";
	const char str3[] = "abc";
	const char str4[] = "abc";
	const char* str5 = "abc";
	const char* str6 = "abc";
	cout << (str1 == str2) << endl;
	cout << (str3 == str4) << endl;
	cout << (str5 == str6) << endl;

输出结果是两行0一行1,就是因为只有数组变量分配在栈区，地址不相同。（数组名就是数组的地址）
下图是四者之间互相转换的关系

第四步，四者转换

如上图所说，char[]可以随便转换为其他的类型，而string可以由任意类型转换而来

const char* c = "123";//可以
char* ch = "123"//提示错误，const char*不能初始化char*类型
char *ch=c；//可以，用const char*初始化char *

所有都能由字符数组转化得来，都能转化为string

int main()
{
	char ch[20] = "abc";
	char* c = ch;
	const char* a = ch;
	string p = ch;
	string q = c;
	string r = a;
	cout << ch << endl << c << endl << a<< endl << p<<endl<<q<<endl<<r;
}
输出：6行abc

所以我们需要考虑的仅仅只是从string开始的转换以及到char[]的转换。

string转换成char*类型

采用两个函数c_str()或data()

string s = "abc";
const char* k = s.c_str();
const char* t = s.data();

值得一提的是，这两个函数返回值只能是const的类型
所以strcpy函数char *strcpy(char* dest, const char *src)

strcpy(s.c_str(),    )

就会提示出错

转换为char[]类型

最简单的方法就是使用strcpy函数

    string s = "efg";
	char ch[20];
	strcpy(ch, s.c_str());
	cout << ch<<endl;

现在string的内容就成功转换到了ch[20]中。
当然，如果由const char或char转换到char[]就不需要c_str()了

const char*和char *

char转化为const char同样是无要求，但是const char*转化为char*就如同VS告诉我们的：不能用const char*初始化一个char*
假如可以的话,那么通过char*就可以修改const char*指向的内容了，但是我们知道，const char*的内容不能被修改。所以还是需要开辟额外的空间(使用strcpy函数).

最后如果想要只转化一部分字符串，strcpy（）就无能为力了，需要使用strncpy函数或者使用简单好用的string类型

 strncpy(a, b+10, 5)//将b数组的第十个开始拷贝五个元素至a

——end