As I'm reading C++ Programming Language and some other tutorials I came on Translation Unit part. I got a bit confused how they work with classes. What is rally not clear to me is inclusion of class headers in different other files that need them. Somewhere in these tutorials I red that each time when we #include a class header, that the current translation unit has its own class. From that I understood that even if we use include guards, that different files, that include same classes, have their own definitions of classes.

So for e.g. let's say that we have two classes A and B. Another two separate files Alpha and Beta, where they include both classes. A third file main.cpp that includes Alpha and Beta, but knows nothing of A and B.
From what I understood is that in main.cpp we will have two definitions of A and two of B, even if A and B use include guards.

Is this true or I confused something?

Trying with different take:

When you use something the compiler needs to know the size and names. 

If you want to say a pointer to something, it needs to know it exists.  If you have a function that takes foo(A* const bar) then the compiler needs to know that A is a thing. The compiler already knows how big a pointer is, but it needs to know that an A is a thing.  

If you're working with actual instances of an object the compiler needs to know how big it is and what data it's got.  If an A is 32 bytes, or 64 bytes, or 256 bytes, or some other size, the compiler needs to know how big it is in order to work with them as objects. If you want to access something inside it the compiler needs to know the name and where the data is at inside the structure.

Inline functions can be part of those descriptions when properly marked so the compiler knows they're not the regular standalone functions.

Header files give those details. 

The compiler allows you to repeat those details as many times as you'd like as long as they're the same every time.  It is generally possible to include files multiple times without being an issue other than longer compile times. 

However, when you've got functions that manipulate those objects, the actual implementation of the class's functions that code should only appear once. Those are part of a compilation unit and can only exist in one place. When other compilation units call the functions the linker links up the call with the one-and-only implementation.

You're allowed unlimited identical declarations with either internal or external linkage, but only one definition.  Most people create a header that is a class definition, but that's not strictly required.

You can be more strict and remove nearly all the implementation details from both the .h and .cpp files, but it's a significant effort.  In large projects with long build times it can help to make occasional passes to do it, but in general it's not done.

Inclusion guard should prevent cyclic/recursion?

2 hours ago, fleabay said:

Please tell me what you think the purpose of include guards are in header files if there is no problem with multiple declarations of the same class in a translation unit.

I did. Again, note the difference between declaration and definition.

4 hours ago, frob said:

Most people create a header that is a class definition, but that's not strictly required.