ChatGPT解决这个技术问题 Extra ChatGPT

How to change string into QString?

What is the most basic way to do it?


s
sth

If compiled with STL compatibility, QString has a static method to convert a std::string to a QString:

std::string str = "abc";
QString qstr = QString::fromStdString(str);

This should actually be avoided in my opinion. If the version of the standard library QT was compiled with is somehow different from what you're compiling with, you're going to have trouble. In creates an unnecessary dependency between QT and libstdc++ that exists nowhere else in QT.
@shoosh: To avoid that couldn't one just do QString qstr = QString(str.c_str());? Not sure whether QString copies what's passed into it.
@shoosh: I understand your concerns about compatability, but both QString and std::string can contain null characters. fromStdString will preserve these, constructing from .c_str won't. (And it was precisely how to do this that led me to this question.)
@MartinBonner QByteArray has a ctor that takes const char* and length. QString has a ctor that takes QByteArray
K
Kamil Szot

If by string you mean std::string you can do it with this method:

QString QString::fromStdString(const std::string & str)

std::string str = "Hello world";
QString qstr = QString::fromStdString(str);

If by string you mean Ascii encoded const char * then you can use this method:

QString QString::fromAscii(const char * str, int size = -1)

const char* str = "Hello world";
QString qstr = QString::fromAscii(str);

If you have const char * encoded with system encoding that can be read with QTextCodec::codecForLocale() then you should use this method:

QString QString::fromLocal8Bit(const char * str, int size = -1)

const char* str = "zażółć gęślą jaźń";      // latin2 source file and system encoding
QString qstr = QString::fromLocal8Bit(str);

If you have const char * that's UTF8 encoded then you'll need to use this method:

QString QString::fromUtf8(const char * str, int size = -1)

const char* str = read_raw("hello.txt"); // assuming hello.txt is UTF8 encoded, and read_raw() reads bytes from file into memory and returns pointer to the first byte as const char*
QString qstr = QString::fromUtf8(str);

There's also method for const ushort * containing UTF16 encoded string:

QString QString::fromUtf16(const ushort * unicode, int size = -1)

const ushort* str = read_raw("hello.txt"); // assuming hello.txt is UTF16 encoded, and read_raw() reads bytes from file into memory and returns pointer to the first byte as const ushort*
QString qstr = QString::fromUtf16(str);

As a quick point fromAscii is now obsolete in QT5...
s
shoosh

Alternative way:

std::string s = "This is an STL string";
QString qs = QString::fromAscii(s.data(), s.size());

This has the advantage of not using .c_str() which might cause the std::string to copy itself in case there is no place to add the '\0' at the end.


With c++11, this is no longer a concern (hidden copy with .c_str())
Prior to C++11, the potential hidden copy was a purely theoretical possibility - no implementations actually did that.
C
Claudiu
std::string s = "Sambuca";
QString q = s.c_str();

Warning: This won't work if the std::string contains \0s.


D
Devolus

I came across this question because I had a problem when following the answers, so I post my solution here.

The above examples all show samples with strings containing only ASCII values, in which case everything works fine. However, when dealing with strings in Windows whcih can also contain other characters, like german umlauts, then these solutions don't work

The only code that gives correct results in such cases is

std::string s = "Übernahme";
QString q = QString::fromLocal8Bit(s.c_str());

If you don't have to deal with such strings, then the above answers will work fine.


This is dependent not on std::string but the encoding of your source file with the string literal. If your source file is UTF8, it will work but break your call to fromLocal8Bit()
G
Gabriel de Grimouard

Moreover, to convert whatever you want, you can use the QVariant class.

for example:

std::string str("hello !");
qDebug() << QVariant(str.c_str()).toString();
int test = 10;
double titi = 5.42;
qDebug() << QVariant(test).toString();
qDebug() << QVariant(titi).toString();
qDebug() << QVariant(titi).toInt();

output

"hello !"
"10"
"5.42"
5

T
Tarod

Do you mean a C string, as in a char* string, or a C++ std::string object?

Either way, you use the same constructor, as documented in the QT reference:

Qt QString Reference

For a regular C string, just use the main constructor:

char name[] = "Stack Overflow";
QString qname(name);

For a std::string, you obtain the char* to the buffer and pass that to the QString constructor:

std::string name2("Stack Overflow");
QString qname2(name2.c_str());

True enough, although the OP didn't mention embedded NULLs. If that is required, you can use QByteArray::QByteArray (const char* data, int size) to wrapper the buffer first, and then pass that to the QString constructor.