C++: Print only one char

Question

When I read one char* from std::cin and I want to write it to std::cout, it prints until it finds a \0 in memory. So what did was:

char c;
cin >> c;
char* pChar = &c;
pChar++;
*pChar = '\0';
println(&c); // My own method: void println(char * str) { cout << str << endl; }

But I don't think this is a safe action.

Is there a safer way to do this?

Answer 1

Simply:

char c;
cin >> c;
cout << c;

Answer 2

The right thing to do when you want to print a character, of course, is to print that character:

char ch;
if(std::cin >>ch) 
  std::cout << ch;
else
  // handle input error

And if you, for whatever reason, want a newline behind every character, then do just that:

std::cout << char << '\n';

Note: You will also see std::endl used for outputting a newline, but std::endl does two things: it outputs a '\n' and flushes the output buffer. While the latter isn't a problem when outputting to the console (it's still faster than a human will be able to read it), I have seen applications becoming to slow (on file output) due to the use of std::endl instead of '\n'. So you'd better learn from the beginning to pay attention whether you need those buffers flushed or not.

---

Note that, where you're doing

pChar++;
*pChar = '\0';

you're invoking the dreaded Undefined Behavior: With pChar++ you are incrementing the pointer to point behind your variable (which is fine), and with *pChar = ... you are writing to whatever memory happens to be behind your variable.
In practice, this will likely corrupt your stack, hopefully making your application crash in the very next moment. In theory, however, this invokes undefined behavior, which, according to the C++ standard, might do anything (including the often cited possibility that it might format your disk).
Do not write to memory that you don't own.
It is hard for beginners to get pointers right, so just avoid them wherever you can. You can do a lot with C++ without ever manually fiddling with pointers.

Answer 3

There already are some answers on how to do what you want to do, but I would like to explain what actually beneath those pchar++ in your code and why it's evil.

C-style casting grants flexibility, but allows you to shoot yourself in the foot. You've allocated char c on the stack (that means you have exact amount of memory reserved for it, and it equals sizeof(char), which is exactlye 1 byte).

Then you take a memory address of your variable (that's ok), so you have your char variable and a pointer to the memory where this char is located. But your next step is completely evil, because you (when doing *(pchar + 1) = 0) are actually corrupting the stack.

As I've told earlier the compiler reserved exactly one byte for your char memory, but what you do means explicitly traversing to the next byte in that memory (which could even belong to other program's stack) and rewriting it with your own values.

This behaviour could be also described with the following example:

Think that you have to alter the contents of some concrete file (a.file) on your hard disk. Do you think it's ok to rewrite the contents of files that sequentially follow a.file, for example, increase the size of that a.file?

Answer 4

char c;
cin >> c;
char pChar[2] = {0};
pChar[0] = c;;
println(pChar); 

Or if you want to be more C++ like, overload the functions:

void println( const char * s ) {
   cout << s << endl;
}

void println( char  c ) {
   cout << c << endl;
}

Or even template:

template <typename T >
void println( T t ) {
   cout << t << endl;
}

Answer 5

Print the character you entered:

char c = 0;
std::cin >> c;
std::cout << c;

Get the character in a string and get the first character:

char c = 0;
std::cin >> c;
std::string str;
str += c;

std::cout << str.at(0) << std::endl;

EDIT

Or maybe you asked for this? :

std::string str;
std::cin >> str;

std::cout << str;

I'm not really sure what is really the problem.

Answer 6

char c;
std::cin >> c;
if (std::cin) {
    std::cout << c << std::flush;
}

That code prints "only one char". std::cout << c << std::endl prints two: c and '\n'.

You can also use your println function if you wanted:

char str[2] = {'\0', '\0'};
std::cin >> str[0];
if (std::cin) {
    println(str);
}

Note that if (std::cin) causes the compiler to invoke the operator void*() const member of the std::ios class, which std::istream extends, in order to evaluate std::cin as a boolean.