converter um char * em std :: string

Eu preciso usar um std::stringpara armazenar dados recuperados por fgets(). Para fazer isso, preciso converter o char*valor de retorno defgets() em std::stringpara armazenar em uma matriz. Como isso pode ser feito?

std::string tem um construtor para isso:

const char *s = "Hello, World!";
std::string str(s);

Observe que essa construção copia profundamente a lista de caracteres em se snão deve ser nullptr, ou o comportamento é indefinido.

Se você já sabe o tamanho do caractere *, use-o

char* data = ...;
int size = ...;
std::string myString(data, size);

Isso não usa strlen.

EDIT: Se a variável de string já existir, use assign ():

std::string myString;
char* data = ...;
int size = ...;
myString.assign(data, size);

A maioria das respostas fala sobre a construção std::string .

Se já estiver construído, basta usar o operador de atribuição .

std::string oString;
char* pStr;

... // Here allocate and get character string (e.g. using fgets as you mentioned)

oString = pStr; // This is it! It copies contents from pStr to oString

Eu preciso usar std :: string para armazenar dados recuperados por fgets ().

Por que usar fgets()quando você está programando C ++? Por que não std::getline()?

Passe-o pelo construtor:

const char* dat = "my string!";
std::string my_string( dat );

Você pode usar a função string.c_str () para o contrário:

std::string my_string("testing!");
const char* dat = my_string.c_str();

const char* charPointer = "Hello, World!\n";
std::string strFromChar;
strFromChar.append(charPointer);
std::cout<<strFromChar<<std::endl;

char* data;
stringstream myStreamString;
myStreamString << data;
string myString = myStreamString.str();
cout << myString << endl;

Gostaria de mencionar um novo método que usa o literal definido pelo usuário s. Isso não é novo, mas será mais comum porque foi adicionado na Biblioteca Padrão C ++ 14.

Em grande parte supérfluo no caso geral:

string mystring = "your string here"s;

Mas permite que você use auto, também com amplas strings:

auto mystring = U"your UTF-32 string here"s;

E aqui é onde realmente brilha:

string suffix;
cin >> suffix;
string mystring = "mystring"s + suffix;

Acabei de lutar com o MSVC2005 para usar o std::string(char*)construtor exatamente como a resposta mais bem avaliada. Como vejo essa variante listada como nº 4 em http://en.cppreference.com/w/cpp/string/basic_string/basic_string sempre confiável , acho que até um compilador antigo oferece isso.

Levei tanto tempo para perceber que esse construtor se recusa a combinar (unsigned char*)como argumento! Recebi essas mensagens de erro incompreensíveis sobre falha na correspondência com o std::stringtipo de argumento, o que definitivamente não era o que eu pretendia. Acabar de lançar o argumento std::string((char*)ucharPtr)resolveu meu problema ... duh!

char* data;
std::string myString(data);

Não sei por que ninguém além de Erik mencionou isso, mas de acordo com esta página , o operador de atribuição funciona bem. Não há necessidade de usar um construtor, .assign () ou .append ().

std::string mystring;
mystring = "This is a test!";   // Assign C string to std:string directly
std::cout << mystring << '\n';