**先看例子**
例一
#include "stdafx.h"
#include <iostream>
#include<math.h>
using namespace std;
class teacher{
public:
teacher(int id,const char *name)
{
m_id = id;
int len = strlen(name);
m_name = (char*)malloc(len + 1);
strcpy_s(m_name,20,name);
}
~teacher()
{
cout << "xigou" << endl;
if (m_name != NULL)
{
free(m_name);
m_name = NULL;
}
}
void printff()
{
cout << "id=m_id" << "name="<<m_name << endl;
}
private:
int m_id;
char *m_name;
};
int main()
{
teacher t1(1,"22");
t1.printff();
teacher t2(t1);//调用了t2的默认拷贝构造函数 t2有指向name的指针，t1也有指向name的指针，先析构t2，导致name的内存不能使用了，t1就不能再使用这个空间了，这就是因为浅拷贝
return 0;
}
**例二**
1class MyException
{
public:
/*MyException(char * str)
{
error = new char[strlen(str) + 1];
strcpy(error, str);
}*/
MyException(const char *str )
{
//法一
error = new char[strlen(str) + 1];
strcpy_s(error,20,str);
//法二
//int len = strlen(str);
//error = (char*)malloc(len + 1);
//strcpy_s(error,20,str);
}
void what()
{
//cout << "未知异常" << endl;
cout << error<< endl;
}
public:
char * error;
//string *error;
};
void func3()
{
throw MyException("cccccc");//默认构造函数，生成匿名对象
}
```
**例三**
class MyException
{
public:
/*MyException(char * str)
{
error = new char[strlen(str) + 1];
strcpy(error, str);
}*/
MyException(const char *str )
{
//法一
error = new char[strlen(str) + 1];
strcpy_s(error,20,str);
//法二
//int len = strlen(str);
//error = (char*)malloc(len + 1);
//strcpy_s(error,20,str);
}
void what()
{
//cout << "未知异常" << endl;
cout << error<< endl;
}
public:
char * error;
//string *error;
};
void func3()
{
throw MyException("cccccc");//默认构造函数，生成匿名对象
}
类中的是char * name;
Person p("aaaa");
这样传递参数的话，构造函数应该写
Person(const int char* str)
{
name=new char[strlen(str)+];
strcpy_s(name,20,str);
}
或者
Person(const int char* str)
{
name=(char*)malloc(strlen(str)
strcpy_s(name,20,str);
}
若直接传递string ("bbbb");如例三
那么接收也应该是string，或者const char *
------------------------------------------------------------
以下为来自https://www.cnblogs.com/kean0048/p/11060559.html
1) char*转string：可以直接赋值。
2) char[]转string：可以直接赋值。
3) char*转char[]：不能直接赋值，可以循环char*字符串逐个字符赋值,也可以使用strcpy_s等函数。
4) string转char[]:不能直接赋值，可以循环char*字符串逐个字符赋值,也可以使用strcpy_s等函数
5) string转char*:调用string对象的c_str函数或data函数或copy函数。
6) char[]转char*:直接赋值即可。
使用时，要对源格式和目标格式进行初始化。源格式赋值为具体的内容，目标格式赋值为空。
总结如下：
A. 变成string,直接赋值。
B. char[]变成别的，直接赋值。
C. char*变const char*容易，const char*变char*麻烦。<const_cast><char*>(const char*);
D. string变char*要通过const char*中转。
E. 变成char[]。string逐个赋值，char* const char* strncpy_s()
## 1、string转char*
把string转换为char* 有3种方法：data(); c_str(); copy();
其中，data()除了返回字符串内容外，不附加结束符'\0'，而c_str()返回一个以‘\0’结尾的字符数组。
1) 调用string的data()函数
string str = "hello";
const char* p = str.data();//加const或者用char *p=(char*)str.data();
同时有一点需要说明，这里在devc++中编译需要添加const，否则会报错invalid conversion from const char* to char *，这里可以再前面加上const或者在等号后面给强制转化成char*的类型。
2) 调用string的c_str()函数
string str=“world”;
const char *p = str.c_str();//同上，要加const或者等号右边用char*
//一定要使用strcpy()函数等来操作方法c_str()返回的指针
//比如：最好不要这样:
char* c;
string s="1234";
c = s.c_str(); //c最后指向的内容是垃圾，因为s对象被析构，其内容被处理
//应该这样用：
char c[20];
string s="1234";
strcpy(c,s.c_str());
//这样才不会出错，c_str()返回的是一个临时指针，不能对其进行操作
//再举个例子
//c_str() 以 char* 形式传回 string 内含字符串
//如果一个函数要求char*参数，可以使用c_str()方法：
string s = "Hello World!";
printf("%s", s.c_str()); //输出 "Hello World!"
3) 调用string的copy()函数
string str="hmmm";
char p[50];
str.copy(p, 5, 0);//这里5代表复制几个字符，0代表复制的位置，
*(p+5)=‘\0’;//注意手动加结束符！！！
2、char*转string 可以直接赋值
string s;
char *p = "hello";
s = p;
3、string转char[]
不可以直接赋值，可以循环char*字符串逐个字符赋值,也可以使用strcpy_s等函数
string pp = "dagah";
char p[8];
int i;
for( i=0;i<pp.length();i++)
p[i] = pp[i];
p[i] = '\0';
printf("%s\n",p);
cout<<p;
4、char[] 转string
可以直接赋值
string s;
char ch[] = "hello world";
s = ch;
5、char[]转char*
可以直接赋值
6、char*转char[]
不能直接赋值，可以循环char*字符串逐个字符赋值,也可以使用strcpy_s等函数。
7、代码实现
1）string转为其他类型
① string转const char*
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
std::string str = "HelloWorld!"; //初始化string类型，并具体赋值
const char* constc = nullptr;//初始化const char*类型，并赋值为空
constc= str.c_str(); //string类型转const char*类型
printf_s("%s\n", str.c_str()); //打印string类型数据 .c_str()
printf_s("%s\n", constc); //打印const char*类型数据
return 0;
}
② string转char*
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
std::string str = "HelloWorld!"; //初始化string类型，并具体赋值
char* c = nullptr; //初始化char*类型，并赋值为空
const char* constc = nullptr;//初始化const char*类型，并赋值为空
constc= str.c_str(); //string类型转const char*类型
c= const_cast<char*>(constc); //const char*类型转char*类型
printf_s("%s\n", str.c_str()); //打印string类型数据 .c_str()
printf_s("%s\n",c); //打印char*类型数据
return 0;
}
③ string转char[]
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
std::string str = "HelloWorld!"; //初始化string类型，并具体赋值
char arrc[20] = {0}; //初始化char[]类型，并赋值为空
for (int i=0; i<str.length();i++) //string类型转char[]类型
{
arrc[i]=str[i];
}
printf_s("%s\n", str.c_str()); //打印string类型数据 .c_str()
printf_s("%s\n", arrc); //打印char[]类型数据
return 0;
}
2）const char*转为其他类型
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
const char* constc = "Hello World!"; //初始化const char* 类型
std::string str; //初始化string类型
str= constc; //const char*类型转string类型
printf_s("%s\n", constc); //打印const char* 类型数据
printf_s("%s\n", str.c_str()); //打印string类型数据
return 0;
}
② const char*转char*
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
const char* constc = "Hello World!"; //初始化const char* 类型
char* c = nullptr; //初始化char*类型
c= const_cast<char*>(constc); //const char*类型转char*类型
printf_s("%s\n", constc); //打印const char* 类型数据
printf_s("%s\n", c); //打印char*类型数据
return 0;
}
③ const char*转char[]
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
const char* constc = "Hello World!"; //初始化const char* 类型
char arrc[20] = { 0 }; //初始化char[]类型，并赋值为空
strncpy_s(arrc,constc,20); //const char*类型转char[]类型
printf_s("%s\n", constc); //打印const char* 类型数据
printf_s("%s\n", arrc); //打印char[]类型数据
return 0;
}
3）char*转为其他类型
① char*转string
int _tmain(intargc, _TCHAR* argv[])
{
char* c = "HelloWorld!"; //初始化char* 类型，并具体赋值
std::string str; //初始化string类型
str= c; //char*类型转string类型
printf_s("%s\n", c); //打印char* 类型数据
printf_s("%s\n", str.c_str()); //打印string类型数据
return 0;
}
② char*转const char*
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
char* c = "HelloWorld!"; //初始化char* 类型，并具体赋值
const char* constc = nullptr; //初始化const char* 类型
constc= c; //char*类型转const char* 类型
printf_s("%s\n", c); //打印char* 类型数据
printf_s("%s\n", constc); //打印const char* 类型数据
return 0;
}
③ char*转char[]
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
char* c = "HelloWorld!"; //初始化char* 类型，并具体赋值
char arrc[20] = { 0 }; //初始化char[] 类型，并具体赋值
strncpy_s(arrc,c,20); //char*类型转char[] 类型
printf_s("%s\n", c); //打印char* 类型数据
printf_s("%s\n", arrc); //打印char[]类型数据
return 0;
}4）char[]转为其他类型
#include "stdafx.h"
#include <iostream>
int _tmain(intargc, _TCHAR* argv[])
{
char arrc[20] = "HelloWorld!"; //初始化char[] 类型，并具体赋值
std::string str; //初始化string
const char* constc = nullptr; //初始化const char*
char*c = nullptr; //初始化char*
str= arrc; //char[]类型转string类型
constc= arrc; //char[]类型转const char* 类型
c= arrc; //char[]类型转char*类型
printf_s("%s\n", arrc); //打印char[]类型数据
printf_s("%s\n", str.c_str()); //打印string类型数据
printf_s("%s\n", constc); //打印const char* 类型数据
printf_s("%s\n", c); //打印char*类型数据
return 0;
}
