How are .cpp files linked to .h files?

Question

C++ / C#

There is file.h, where the class is simply described.
There is file.cpp, where the implementation of this class is described.
in main.cpp, in main, I create an object of class file, after including "file.h".
How does he understand what the implementation is in file.cpp?
Logically, I just connect the header, where the prototypes are, and there is no data for the file file.h that the implementation is in cpp.

Answer 1

The linker is looking not for an implementation file, but for a method (actually, it's called a "symbol") with the appropriate name.
The linker is passed a list of object files, and it searches all of them for a method with the desired signature.
If two object files contain the same symbol, the linker will complain. The linker does not look at *.h.

Answer 2

How does he understand what the implementation is in file.cpp?

It's very simple: you feed this file to the compiler, and everything in it gets into the common global space. After processing by the preprocessor, all this looks like it is not in several files, but in one.
As a result, file.h file.cpp main.c become one file.

Answer 3

Let me clarify the situation a little. At first there is a compilation of all c/cpp (and not only - that you will specify to the compiler) files. When compiling from the source code, the preprocessor goes through and substitutes the contents of the included files instead of #include. Thus, both main.cpp and file.cpp will first contain file.h with a class description. The output for each class compilation unit is an object file with compiled code, where instead of function addresses it is indicated which function should be put when linking (function name modified by the compiler, reflecting the list of function arguments, calling method, etc., see name mangling ).
When linking, all the specified object files, libraries (just a container for object files) are collected into one executable file - here the linker already finds that a function is called from main.obj from a certain function, from file.obj, and substitutes the required call.
In fact, .h files are sugar, so as not to write something many times in each compiled forward declaration module, and the compiler may not even know anything about the existence of the same .h files if the preprocessor is implemented as a separate program (see more about the C preprocessor).