Question: I don't understand why don't they have a copy constructor which makes a real multiple of the original.

As we know the main problem of the default copy constructor is, that it performs a shallow copy. So that if there is a pointer it would only copy it's address but why doesn't it dereference the pointer a copies the content?
The main problem arises when having a dinamic allocation of memory . So that one can mistakenly delete it while having a pointer pointing to it, that's why we make our own copy constructors and do not use the default one.

But I can't get it, why doesn't CPP do it? Why doesn't it copy the content

Answer: 
> 
> As we know the main problem of the default copy constructor is, that it performs a shallow copy.
> 
> 
> 

We don't know that.

> 
> that's why we make our own copy constructors and do not use the default one.
> 
> 
> 

In C++ you should almost never write your own copy constructor ([the rule of zero](https://en.cppreference.com/w/cpp/language/rule_of_three)).

> 
> The main problem arises when having a dinamic allocation of memory . So that one can mistakenly delete it while having a pointer pointing to it
> 
> 
> 

It's a non-problem. Why? Because in C++ we use the concept of [RAII](https://en.cppreference.com/w/cpp/language/raii) and we have tools in the standard library that solved all of the problems you see. In C++ you should never have to write explicit `new` and you should never have a raw pointer that is a owner. Use standard containers (e.g. `std::vector`) and smart pointers e.g. (`std::unique_ptr`).

> 
> I don't understand why don't they have a copy constructor which makes a real multiple of the original
> 
> 
> 

Because the compiler doesn't know what the copy-semantics of the object should be. That only the writer of the class knows. You can't know what the semantics of the pointer are. Is is a pointer that uniquely owns the memory resource? If so, was it acquired with `malloc`, `new`, `new[]`, or with something else? Does it share its ownership of the memory? Or is it simply pointing to an object it doesn't own? Since you cannot know any of this from the declaration/definition of a class, a compiler simply cannot implement "deep copy" automatically with raw pointers.

Except **it does**. It does implement deep copy by default, or shallow copy by default, or a combination of them. And it does so correctly. Remember when I told you to not use raw pointers for ownership? Use the appropriate abstractions (containers, smart pointers) and the default copy ctor will do exactly what it needs to do.
The compiler has no way of knowing the meaning of the pointers it is supposed to "deep copy".

For example, does a float pointer point to a single float or to a C-style float array? If it is an array, what is the length of the array that it should copy? Please note that I am not talking about C++ style arrays (i.e. `std::array`).

If you want "deep copying" to be handled automatically, you can use [container classes](https://en.cppreference.com/w/cpp/named_req/Container) for data members that should be copied.