我的理解是，字符串是std名称空间的成员，那么为什么会发生以下情况?
#include <iostream>
int main()
{
using namespace std;
string myString = "Press ENTER to quit program!";
cout << "Come up and C++ me some time." << endl;
printf("Follow this command: %s", myString);
cin.get();
return 0;
}
每次程序运行时，myString输出一个看似随机的3个字符的字符串，如上面的输出。
当前回答
如果你想要一个类似c的字符串(const char*)用于printf，请使用myString.c_str()
谢谢
其他回答
如果你想要一个类似c的字符串(const char*)用于printf，请使用myString.c_str()
谢谢
您可以使用snprinft来确定所需的字符数量，并分配适当大小的缓冲区。
int length = std::snprintf(nullptr, 0, "There can only be %i\n", 1 );
char* str = new char[length+1]; // one more character for null terminator
std::snprintf( str, length + 1, "There can only be %i\n", 1 );
std::string cppstr( str );
delete[] str;
这是对cppreference.com上一个例子的一个小的改编
Printf is actually pretty good to use if size matters. Meaning if you are running a program where memory is an issue, then printf is actually a very good and under rater solution. Cout essentially shifts bits over to make room for the string, while printf just takes in some sort of parameters and prints it to the screen. If you were to compile a simple hello world program, printf would be able to compile it in less than 60, 000 bits as opposed to cout, it would take over 1 million bits to compile.
对于您的情况，我建议使用cout，因为它使用起来要方便得多。尽管我认为printf是值得了解的东西。
使用std::printf和c_str() 例子:
std::printf("Follow this command: %s", myString.c_str());
请不要使用printf("%s"， your_string.c_str());
使用cout << your_string;代替。简短，简单，类型安全。事实上，当您在编写c++时，您通常希望完全避免printf——它是C的遗留物，在c++中很少需要或有用。
至于为什么应该使用cout而不是printf，原因有很多。以下是一些最明显的例子:
As the question shows, printf isn't type-safe. If the type you pass differs from that given in the conversion specifier, printf will try to use whatever it finds on the stack as if it were the specified type, giving undefined behavior. Some compilers can warn about this under some circumstances, but some compilers can't/won't at all, and none can under all circumstances. printf isn't extensible. You can only pass primitive types to it. The set of conversion specifiers it understands is hard-coded in its implementation, and there's no way for you to add more/others. Most well-written C++ should use these types primarily to implement types oriented toward the problem being solved. It makes decent formatting much more difficult. For an obvious example, when you're printing numbers for people to read, you typically want to insert thousands separators every few digits. The exact number of digits and the characters used as separators varies, but cout has that covered as well. For example: std::locale loc(""); std::cout.imbue(loc); std::cout << 123456.78; The nameless locale (the "") picks a locale based on the user's configuration. Therefore, on my machine (configured for US English) this prints out as 123,456.78. For somebody who has their computer configured for (say) Germany, it would print out something like 123.456,78. For somebody with it configured for India, it would print out as 1,23,456.78 (and of course there are many others). With printf I get exactly one result: 123456.78. It is consistent, but it's consistently wrong for everybody everywhere. Essentially the only way to work around it is to do the formatting separately, then pass the result as a string to printf, because printf itself simply will not do the job correctly. Although they're quite compact, printf format strings can be quite unreadable. Even among C programmers who use printf virtually every day, I'd guess at least 99% would need to look things up to be sure what the # in %#x means, and how that differs from what the # in %#f means (and yes, they mean entirely different things).
