Pointer size on x86 and weird characters output

Question

#include <iostream>
#define SIZE 2

int main(int argc, char** argv)
{
    char w = 'a';
    char *array[SIZE];
    array[0] = &w;
    std::cout << *array << std::endl;
    system("PAUSE");

    return(0);
}

The output of the program is: a╠╠╠╠┴Kôè∞≈5«,┌.

Char is one byte long so the output should be: a

Or it outputs the garbage because the pointer size is 4 bytes(for int, double, float, char) for x86 and all of the garbage is those 3 bytes?

Answer 1

char *array[SIZE];

You're declaring an array of char pointers, each element of that array is a char*, then

char[0] = &w;

You're assigning the 0th pointer the address of variable w.

std::cout<<*array<<std::endl;

is the same as

std::cout<<array[0]<<std::endl;

You're trying to print the 0th pointer, which you set to not null-terminated string, anything can happen from there as you're reading random things from memory.

Answer 2

This has nothing to do with pointer sizes or the sizes of built-in types.

The code stores the address of a character in array[0], then sends that address to std::cout. When you insert a char* into std::cout the inserter assumes that the pointer points at a nul-terminated character array. There is no nul terminator here, so it goes on writing stuff until it hits a zero. Formally, the behavior is undefined.

You'd get the same thing, more clearly, with char* array = &w; std::cout << array << '\n';. Or, even simpler, std::cout << &w << '\n';.

To write the value of the character, use std::cout << w << '\n'; or, if you need to use that array, write out the character at the beginning of the array. That's array[0][0] or, if you like direct dereferencing, **array.

Answer 3

Char is one byte long so the output should be: a

That length of "one byte" hasn't been stored anywhere in your compiled program.

A pointer, like char *, to one byte is no different than a pointer to many bytes. The pointer does not know.

When you send a character pointer to std::cout, that stream is designed to output successive characters until a null character is encountered. That's how it is determined how many characters should be output. The pointer doesn't know, so the data pointed to is expected to mark its end.

Answer 4

Arrays used in expressions with rare exceptions are converted to pointers to their first elements.

From the C++ Standard (4.2 Array-to-pointer conversion)

1 An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to a prvalue of type “pointer to T”. The result is a pointer to the first element of the array.

So in this statement

std::cout << *array << std::endl;

the sub-expression array has the type char ** because elements of the array have the type char *.

Thus the expression *array has the type char *. And you are trying to output a string pointed to by the pointer *array that is not zero-terminated. So the program has undefined behaviour. It outputs all characters following the character 'a' until a zero character is encountered in the memory.

You need to write

std::cout << **array << std::endl;

to output just one character.

Here is a demonstrative program

#include <iostream>

int main() 
{
    const size_t SIZE = 2;
    char w = 'a';
    char *array[SIZE];
    array[0] = &w;

    std::cout << **array << std::endl;  

    return 0;
}

Its output is

a

This statement

std::cout << *array << std::endl;

would work fine if after the character 'a' in your object there will be a zero-character that is if the statement would deal with a string.

For example

#include <iostream>

int main() 
{
    const size_t SIZE = 2;
    char w[] = { 'a', '\0' };
    char *array[SIZE];
    array[0] = &w[0];

    std::cout << *array << std::endl;   

    return 0;
}

The program output is the same as shwon above.