Unless I am missing something, from what I see, "username" and "password" are declared inside of a struct and you are attempting to use them as global variables ( pointers ) .

Edit: All variables should be initialized when they are created.

default_user.username is a character pointer, so taking it's address is creating a pointer to a point. You're writing the data at that address, and whatever happens to be after it, to the file. There is no inherent meaning to this data.

There are a few common ways of storing strings:

I'm going to assume we'll use the first mechanism. Writing is fairly easy, just dump the data pointed to by the string, including the NUL terminator.

void writeString(std::ostream &out, const char *string)
{
    int count = std::strlen(string) + 1;
    out.write(string, sizeof(char) * count);
}
 
// ...
 
writeString(test_usernames_c, default_user.username);
writeString(test_usernames_c, default_user.password);

Now, the complicated part is reading, as we can't predict in advance how many characters we will need. The simplest solution is to read character by character:

std::string readString(std::istream &in)
{
    std::string result;
    while (true)
    {
        in.read(&c, sizeof(char));
        if ( c == '\0' )
        {
            return result;
        }
        else
        {
            result += c;
        }
    } 
}
 
std::string username = readString(test_usernames_c);

Note: you'd probably be better off using std::string in your User struct. Manually juggling character pointers is not recommended, it opens you up to a whole slew of potential bugs, whereas std::string is much harder to break.

Also, the code here ignores I/O errors, you should add such checking too.

Ok, this is bad, mmmkay?

user default_user;
default_user.username = "user";
default_user.password = "1234";

You probably aren't doing what you think you are doing here. Basically you a priming a live hand grenade with this code.

A pointer points at a location in memory, that's why they get their name. However, when you declare a pointer, that memory ISNT allocated.

Going in to a big thing about how pointers work is a bit beyond what a forum like this is for ( for more details on C++ memory allocation, try this guide. ), I would highly recommend you start learning from a different source. Also, is there a reason why you are writing very old school C code here? I think my biggest suggestion is, pick a different learning source.

EDIT: Ugh, just noticed this line...

user14 = new user;

So... this is C++ code after all and not actually C. In that case, there are many many many problems with it, and more likely, from whatever source you are learning from being horrifically out of date. For example:

• struct typedef
• direct memory usage in the first place
• old school IO code
• not using std::string

It "works" because you assigned your pointers a value, so they point to something, even if that something is completely random.

consider....

char* myExplosiveVariable = "Idontreallyexist";

std::cout << myExplosiveVariable[0];

This code will run, but isn't doing what you think it is.

The value "Idontreallyexist" isn't being assigned to myExplosiveVariable, it's location is. For now, that location kinda makes sense, but once you've gone out of scope then it no longer will. Now here's the thing, even though a variable is out of scope, that doesn't mean the contents get wiped, so a pointer to a variable that has been deallocated will continue to work... until that memory is reused, at which point... BOOM.

Well I know that I need to initialize the data thats why I asked why it works. Seems if I declare the struct without typedef it works. I thought writing user.username = "blala" it intitialize the pointer with a buffer that contains "blabla" so I dont need to make a new to initiate data for that pointer. Also I though write() function from files initiates data for me so the pointer will point a valid buffer.

Nope, this is where you went wrong.

It's important again to remember, pointers only point to stuff. So what you are actually doing is creating a local temporary variable with the value "blala" and pointing at it's location. The problem is, if that pointer outlives that location in memory, you run into a world of hurt.

This is where new comes in. Consider the line

char * myStuff = new char(100);

This is actually doing TWO things. A buffer in memory is being allocated that stores 100 chars, that's the new char(100) part. THEN a char * pointer is being created that points at that buffer. The initialization part is the new call.

It's because you rely on undefined behaviour. Undefined behaviour is what occurs when you write some code which violates some of the rules in the C++ standard. The C++ compiler chooses to "ignore" these cases, because to find them generally involves adding run-time checks, which is counter to the C++ design philosophy. Instead, you, the programmer, are expected to be perfectly familiar with the C++ standard and not write code that falls into "undefined behaviour".

If the C++ compiler generates a machine executable from such a program, as the name implies there is no restriction on what that program can do. It can fail to start, it can crash, it can run but silently corrupt it's own state. It is technically possible that such a program could erase all the user's files, though for most programs that is spectacularly unlikely.

So, you had a program that depended on undefined behaviour, and it "appeared" to work. But that isn't necessarily true, as if you compile it in another compiler, it may not "work". Or if you make a change elsewhere in the program, it may appear to break.

This is why you're getting different behaviour when using a local variable and a pointer in a dynamically allocated structure.