Why are private variables described in the publicly accessible header file?

Question

OK, so hopefully this is a subjective enough question for Programmers, but here goes. I am continuously broadening my knowledge of languages and software engineering practices... and I've run into something that just makes no sense to me whatsoever.

In C++, class declarations include private: methods and parameters in the header file, which, theoretically, is what you pass to the user to include if you make them a lib.

In Objective-C, @interfaces do pretty much the same thing, forcing you to list your private members (at least, there's a way to get private methods in the implementation file).

From what I can tell, Java and C# allow you to provide an interface/protocol which can declare all the publicly accessible properties/methods and gives the coder the ability to hide all implementation details in the implementation file.

Why? Encapsulation is one of the main principles of OOP, why do C++ and Obj-C lack this basic ability? Is there some kind of best-practices work-around for Obj-C or C++ that hides all implementation?

Thanks,

Answer 1

The question is whether the compiler needs to know how large an object is. If so, then the compiler has to know about the private members in order to count them up.

In Java, there's primitive types and objects, and all the objects are allocated separately, and the variables containing them are really pointers. Therefore, since a pointer is a fixed-size object, the compiler knows how big a thing a variable represents, without knowing the actual size of the pointed-to object. The constructor handles all of that.

In C++, it's possible to have objects represented locally or on the heap. Therefore, the compiler needs to know how big an object is, so that it can allocate a local variable or array.

Sometimes it's desirable to divide class functionality into a public interface and a private everything else, and that's where the PIMPL (Pointer to IMPLementation) technique comes in. The class will have a pointer to a private implementation class, and the public class methods can call that.

Answer 2

Due to the design of C++, in order to create an object on the stack the compiler must know how big it is. To do this it needs to have all the fields present in the header file, as that is all that the compiler can see when the header is included.

For instance if you define a class

class Foo {
    public int a;
    private int b;
};

then sizeof(Foo) is sizeof(a) + sizeof(b). If there was some mechanism to separate the private fields, then the header might contain

class Foo {
    public int a;
};

with sizeof(Foo) = sizeof(a) + ???.

If you want to really hide private data, try the pimpl idiom, with

class FooImpl;
class Foo {
    private FooImpl* impl;
}

in the header and a definition for FooImpl only in Foo's implementation file.

Answer 3

This all comes down to the design choice.

If you truly wish to hide the private implementation details of the C++ or Objective-C class, then you either provide one or more interfaces that the class supports (C++ pure virtual class, Objective-C @protocol) and/or you make the class able to construct itself by providing a static factory method or a class factory object.

The reason that the private variables are exposed in the header file/class declaration/@interface is that a consumer of your class might need to create a new instance of it and a new MyClass() or [[MyClass alloc]init] in the client code needs the compiler to understand how big a MyClass object is in order to do the allocation.

Java and C# also have their private variables detailed in the class - they are no exception to this, but IMO the interface paradigm is much more common with those languages. You may not have the source code in each case, but there's enough metadata in the compiled/byte-code to deduce this information. As C++ and Objective-C don't have this metadata, the only option is the actual details of the class/@interface. In the C++ COM world, you don't expose the private variables of any classes yet can provide the header file - because the class is pure virtual. A class factory object is registered to create the actual instances too, and there's some metadata in various forms.

In C++ and Objective-C, it is less work to hand out the header file compared to writing and maintaining an additional interface/@protocol file. This is one reason that you see the private implementation exposed so often.

Another reason in C++ is templates - the compiler needs to know the details of the class in order to generate a version of that class specialized to the parameters provided. The size of the class's members would vary with the parameterization, so it needs to have this information.