Initialize a private static field outside the class (the meaning of private in this case) and calling to static functions

Question

If I will define a private static field in class. Given that it's a private field, can't I initialize it outside the class?

class X{
    static int private_static_field;
public:
    static void setPrivateStaticField(int val);
};

void X::setPrivateStaticField(int val) {
    private_static_field = val;
}


int X::private_static_field(0); // something like that it's ok? if yes, I must write this line? why? can I write it in main?

It's look that it's ok (according to the compiler), but if so, I don't understand the concept of private - How it's ok if it's outside the class?

---

In addition, given the class above, and the next code:

int main() {
    X x1();
    x1.setPrivateStaticField(3);
    return 0;
}

What is the meaning of x1.setPrivateStaticField(3); , after all, this function is static and hence it's not related to some object.
Hence, I don't understand how it's ok to call setPrivateStaticField with object (x1) ?
(I thought that just X::setPrivateStaticField(3); will be ok and that x1.setPrivateStaticField(3); will be error)

Answer 1

I don't understand the concept of private - How it's ok if it's outside the class?

There is no contradiction here. Prior to C++ 17 static member variables required a definition that is placed separately from the class declaration.

Despite the fact that the text of the definition is placed outside the class, the member variable remains part of the class where it is declared, and retains its accessibility according to its declaration inside the class. This includes private accessibility.

What is the meaning of x1.setPrivateStaticField(3); , after all, this function is static and hence it's not related to some object.

Although C++ compiler lets you call static member functions on the object, it is cleaner to call them using scope resolution operator :: and the class name:

X::setPrivateStaticField(3);

Allowing or disallowing class method calls on an instance is up to the designers of the language. C++ designers decided to allow it; designers of other programming languages disallow it, or require compilers to issue a warning.