Question

So, I am willing to structure my project like that:

ClassA.cpp:

class ClassA {
public:
    static ClassA* create() {
        return new ClassA();
    }
    void methodA() {
        // stuff here
    }
    void methodB() {
        // more stuff here
    }
private:
    ClassA() {
    }
    void privateMethodOne() {
        //yadda yadda
    }
    int attributeA;
    char attributeB;
};

ClassA.hpp:

class ClassA {
public:
    ClassA* create();
    void methodA();
    void methodB();
private:
    ClassA();
};

I am going to work only with pointers, I wonder if this approach would generate an error in a future. I wonder if there is a pitfall here. Suppose that the .hpp is automatically generated so it would have exactly the same members, except the private ones.

Answer 1

This approach is not valid. C++ has the one definition rule. See C++03 section 3.2 for full details, but here is Wikipedia’s summary (highlighting is mine):

In short the ODR states that:

1. In any translation unit, a template, type, function, or object can have no more than one definition. Some of these can have any number of declarations. A definition provides an instance.
2. In the entire program, an object or non-inline function cannot have more than one definition; if an object or function is used, it must have exactly one definition. You can declare an object or function that is never used, in which case you don’t have to provide a definition. In no event can there be more than one definition.
3. Some things, like types, templates, and extern inline functions, can be defined in more than one translation unit. For a given entity, each definition must be the same. Non-extern objects and functions in different translation units are different entities, even if their names and types are the same.

You may be looking for the PIMPL idiom, which is a way to “hide” private members from the public interface (i.e. the public header file).