why do header files even exist?
Vložit
- čas přidán 15. 09. 2023
- So why do we use header files? Are they just there to look pretty? Is there actually a reason that we include them in all the code we write? In this video we explore how the compiler works, how the linker works, and how header files tie the whole process together.
🏫 COURSES 🏫 Learn to code in C at lowlevel.academy
📰 NEWSLETTER 📰 Sign up for our newsletter at mailchi.mp/lowlevel/the-low-down
🙌 SUPPORT THE CHANNEL 🙌 Become a Low Level Associate and support the channel at / lowlevellearning
How Does Return Work? • do you know how "retur...
🔥🔥🔥 SOCIALS 🔥🔥🔥
Low Level Merch!: lowlevel.store/
Follow me on Twitter: / lowleveltweets
Follow me on Twitch: / lowlevellearning
Join me on Discord!: / discord - Věda a technologie
wanna get good at programming? check out lowlevel.academy and use code THREADS20 for 20% off lifetime access. or dont. im not a cop
idk man
+1
same dude.
same i'm literally shaking holding my JS teddy bear
now you know man
great
You can also use a header files to declare structs w/o exposing their fields (you define them in the source file). That way you ensure that users of your library operate on structs only through pointers to them and API you provided, so you achieve encapsulation.
public in any language: hello
Sounds like security by obscurity. Someone will eventually guess the names of your "private" fields!
@EdKolis it's not security, it's what the developer is able to use in source code. Of course there's ways to get around it, but the point is just to make it harder to do something you don't want them doing.
Is that what they call the Pimpl pattern?
Won't it cause allocation problems? When sizeof(struct) lies to you about real size? Or am I wrong somewhere?
Be careful with those $(pwd) calls, they undergo bash word expansion and can be broken into two different arguments if your path has a space in it, always quote those things with double quotes ", same if you were to do "$PWD" (just reading the variable PWD instead of running the pwd command in a subshell)
Fuckin' sh, man. How'd it catch on?
There are so many things that break if you have a space in the path for this reason!
in short: header files are just C source files that are merged into the files you #include them into by the preprocessor. Header files usually contain declarations to tell the compiler "hey I know you can't find this function's definition anywhere, but trust me, it'll linked in by the linker."
Header files basically tell the compiler that certain functions exist in a library, that'll be linked in by the linker.
Header files are only there because it makes it easier for the parser. They are technically not needed but this is the legacy of C and other languages so it's stuck around. I don't mind them personally but it's hard to justify their existence because removing them is just an technical problem which can be solved with a little effort.
I was just thinking the same. If one is naughty, one could completely ignore header files and just use implicit declarations all around.
C could use an actual module system like Rust but I suspect that's not going to happen any time soon. I heard C++20 introduced a module system, but then you're programming in C++ .... or some subset of it.
i dont get it, how would certain functions run then?
@@atif1538 the compiler would just create an implicit declaration for any external function, which will always look like int functionName() (always an int and empty parameters). The linker will then just try to match the function name to what it can find in the libraries. If you pass the correct arguments to the functions and handle its return value correctly, everything should work just fine.
@@kerimgueney Wow, did not know that. Thanks for info!
@@kerimgueneyso u could just include another .c file with the definitions and wouldnt need a header file?
Something you didn't mention is that header files are included in the precompiler phase. The line _#include__ "myheader.h"_ is basically an instruction that tells the precompiler to replace this line with the contents of _myheader.h_ . This is why header inclusion is a # command, and also why headers start with a #ifndef command, to make sure that the same header isn't included more than once by the precompiler. It also means that you don't have to limit yourself to declare functions on the header file, you can technically write any code inside a header file and it will compile just fine, though it can lead to problems if multiple source files use the same header (multiple definition error).
inline my beloved
Headers could also start with a "#pragma once" command.
> though it can lead to problems if multiple source files use the same header (multiple definition error).
But why? Doesn't #ifndef/#pragma once fix this?
@@dimitar.bogdanov the ifndef/pragma prevents you from getting multiple definitions in one translation unit, but if you link with another compiled source file that included the header then you would basically be including that code twice, because each source file has its own copy of the header
@@davidfrischknecht8261 #pragma once is nonstandard.
Dealing with header files in c/c++ feels like doing the job of the compiler. I understand the need of a header file when linking with dynamic/static library. BUT in 99% of header files I wrote I also wrote the source file.
Having implentations in headers leads to longer compile times, separate file.cpp can be compiled to object files indelendent of other code
The header files will be useful if you get a new task that takes say 6 months and then need to return to the task, and also if you rise in the career and someone else needs to understand what you coded. Just regard them as your own well structured notes for yourself (and others).
Dealing with header files is one of the reasons why I decided to go with Java development career instead of C/C++.
@@rursus8354Yes, that is what comments are for. In the best case, the header just says what the source file says. In the worst case, the header is a complex maze of ifdefs that are impossible to navigate.
When C and C++ were developed there wasn't such concept as module
"Declaration" and "definition" have very specific meanings in C. You got it right at one point in the video, where you said the declaration is in the header but not the definition, but you kept using the wrong terms throughout the rest of the video. K&R assumed an implicit declaration of unknown functions as returning an int - parameters were not part of the signature - but ANSI made declarations for functions mandatory and added parameters.
Instead of "why do header files even exist" you explained how header files work, but the question from the title of the video still stands.
You may have noticed that header files are almost exclusive to C/C++ languages, other languages somehow don't need them. So why do header files even exist?
For those wondering, header files exist mostly for historical reasons. Since memory was very limited back when C was developed, compilers couldn't afford to keep track of modules themselves, so it became the job of the programmer. Modern compilers are far less hardware restricted, which allows them to favor developer experience over efficiency.
Can you make more videos about the building process?
I really enjoyed this one
Your channel is making me a better programmer one video at a time. I'm really thankful for that since I mostly just learned to use programming as a tool to get things done, but as a computer architect with a mathematics background I really prefer to understand how things really work. So a huge thanks from me to filling these gaps one step at a time!
I know someone said you are a gem for embedded, but you are also one for game dev and low levelers with hardware restraints. I love it.
I am just a little to deep, but I saw 'header file' reading the raylib documentation as being modular and interchangable.
And I would be lying to say I had any clue what a header file or what a C file with a header file really...means.
This video clears up alot of over complicated imagined semantics. Thanks!
man your awesome, you just answer the most intricate questions devs have. I just had this doubt today and you video came in. Great service. Thx again.
I love your work man, although I know this info already but I'm enjoying watching you explaining it with this much practical details.
This reminds me of my earliest programming experience where it was still common to do the compile and linking semi manually. It was also common to have an automation, but still when I started, and this was not as long ago as you might think, manually compiling and linking simpler programs was still considered common practice.
I’ve never found header files an issue, if anything I find them a blessing. A nice readable prototype of an implementation for a function that I don’t want to know the implementation details from. I hear everybody complain about it and it makes no sense to me as to why. I hate those people who do implementations also in header files.
Just to add if you don’t mind.
I remember Bob C. Martin and someone else explains header file being similar to Go/Java interface and it could be made to serve the purpose of hiding private functions.
Lately though I have doubts about the abstraction layers itself. I encounter most of the times hiding the details behind interfaces makes behaviour of code harder to understand but that’s anecdotal. While at the same time, there is no way to code without abstraction.
@@candrar2866 nice addition!
Usually I don’t hold uncle Bob in a very high regard but a header can be seen as an interface definition.
Now that’s the difference between Java and C++ you have all the definition public, private, protected. Which shouldn’t be needed really but back in 1970 when C was created the sole purpose was to develop operating systems. Those systems didn’t have the power to quickly scan binaries to find functions and bind to them. Because reading binaries was so slow. So basically the whole header files started as a helper for underpowered linkers.
These days we can do that without effort and the idea of a header file is dropped in all modern languages.
But I do like a header file strictly as an interface like Uncle Bob sees them. You get a binary library and a header file and you know exactly how to call the functions.
I fully agree
You know you can just collapse the function contents in any proper editor to get basically the same information? IIRC it's ctrl-K ctrl-0 in VSCode.
@@imaginerus then you will need to send the code along and compile the whole code. The idea of libraries is that these are already in binary format.
thank you so much for explaining this, i didn't get it each time someone tries to explain it to me but you did explain it so good! you are a geat teacher, thank you
Technically, in the last step you could just list all your .c files instead of .o files, but it would mean you have to compile both files every time even if only one of them changes.
It would have to be huuuuge to make a real impact in todays processing speeds
A video explaining pointers in the context of structs and vectors being passed to function would be great (What is the best way to access the value of a struct/array and assign it to another struct or variable inside of a function for example...), also one on cmake and best practices when developing with C would be awesome as well, just some suggestions! Thank you for the helpful videos!
Great video, I've used C a bit, not loads, and you explained so many things that I just kinda accepted without really fully understanding.
A great way to show this is with objdump output on .o files, .so files, and executables.
It might be fun to do one about why the order of linker arguments matter (it's an iterative process!)
Basically the implicit function declaration already knows the arguments and return of the function.
If compiled to assembly/binary, it can pass its parameters into appropriate registers and read back an expected return from the return register.
But the binary also needs to know the address of the function, to jump there and continue with the code execution of that function. To find out this address, the files need to be linked.
If no matching function can be found at this time, the linker can only give up.
In many modern strongly typed languages and IDEs, we would expect the IDE to already have done that lookup in real time as we type the code, so we may not even be allowed to start compiling.
great definition, this was the first thing I had to figure out decades ago with circular dependencies
Very helpful video, this helped a lot. Thanks, dude.
I have been looking for a good video about this for a long time 😂 thank you!!
Thank you very much, I literally dealt with tons of compiling issues when programming in go using the FFI and realized that I have never understood it correctly.
Great video! Nicely presented! 👌
C learner here. Great video. I use #pragma once and intend to have declarations in the header files, but I often struggles in a projects, where I have multiple .c and .h files. I think of two ways to deal with that. Use static more and move some of the declarations to the related .c file.
Awesome channel, fills in a lot of my knowledge gaps efforlesly!
Btw, for linker paths in e.g. proprietary programs, patchelf from the NixOS project exists. It lets you change paths to libraries in standard Linux ELF files, which they have to use as that distro doesn't use /usr/lib.
Great explanation. Thank you
At first, I didn’t appreciate headers, I considered them cumbersome. I always thought that you’re repeating yourself. Then I started writing a rendering engine, and oh are they a lifesaver. Declaring one header file that’s used across 4 APIs has saved me a lot of time and effort instead of writing one for each.
Wow, this is such great information that I found a week after I needed to know it.
07:12 Doing `$(pwd)` instead of `$PWD` is like doing `cat file | grep pattern` instead of `grep pattern file` 💀
Great video, learned a lot.
Wow, I really like the shirt he's wearing. Assembly language just got more interesting.
Very well rounded discussion of header files. Although, you could have added more detail like pragma options and such, I like the way you discussed it since it's easier for beginners to understand without all of the details they can learn later.
My first Cpp project was a game-engine following theCherno’s tutorial to start and I learned how to use header files kinda naturally i never even thought about “why” im doing i just new when to use it
Actually, I started learning c++ the exact same way, about 2 years ago with his sparky series.
Are you still working on that!?
Awesome explanation! Thanks!
Can you talk about the pimpl idiom? I've seen it discussed as a way to hide implementation details, but I've never understood it.
THANK YOU I NEED THIS
How did you get your vim? nvim? to look like that? Do you have a tutorial for it?
3:11 Can you have another look at this? I think this was suppose to say "link -> dll" for windows? As far as I know static libraries (*.a / *.lib) are not linked at all. e.g. on linux the command "ar" will just bundle several *.o files into a single *.a. No linker involved. It would be great to see a deep dive in how static and dynamic libraries work in detail.
so to define files to liker I need to use GCC for example or any other compiler, is that right?
6 years after completing classes, i learned why and "" are used in the includes.
Isn't it simply because these source files actually don't know about each other? Each unit is compiled separately, only linking at the ends brings those units together.
Thank you for the helpful video! At 7:52, I think you misspoke by saying "defined" instead of "declared".
We need a video on makefiles!
Exactly the video I needed.
This video was just perfect
This is a gem.
I *really* wish this video (or something equivalent) had existed when I first started learning C in the 80s, because this stuff confused the hell out of me at the time, & was never explained properly in the texts I was learning from.
This was fantastic.
This doesn't explain WHY the header file exists. It explains WHAT the header file is used for...
Bro how can't you understand the purpose of a library. Have you programmed in python? The reason why it exists is first because you need some order and no matter how much you order a file when it has thousands of lines of code its a bit messed up. And secondly its really convenient to take a functionality that someone already made and use it right away.
I'm excited to start the course but I'm experiencing a problem. When I try to watch any video other than the introduction, I get redirected to the purchase page. (I already bought the product) Can you kindly check what's happening?
how does including the client.h in code.c give access to the definitions in client.c?
How are you able of highlighting the text both in Vim and in the terminal so fast, even when the cursor seems to be somewhere else? Care to share your tricks?
For data that is not self-describing, you need a way to share the common structure across multiple source code files. It's also helpful for sharing common source processing directives. This concept originated before computers with "boilerplate" text and copy books and the term "copy book" was adopted by Amazing Grace for Cobol.
Hello LLL!
Could you explain what happens in the linking process? What does it do to the object file? How can the executable locate the library code at runtime to execute it? I like to know how this whole world of references and dependencies works in Linux.
Thank you very much for sharing your knowledge, I really appreciate it.
Can you please explain stb style header files?
love your channel
For future viewers.. newer compilers will treat 1:39 as an error (as if -Werror=implicit-function-declaration) not as a warning as t is invalid c99..the link step will not ocurr.
Please do a video that analyzes C++ objects at the assembly level
I think header file is also the way to make function implementation private/hidden from the end user
Fantastic video.
First time I’ve really understood the linker vs compiler
Header fights create a prototype declaration of the interface to a full actual function.
Only at link time you'd need the code for the function. Ultimately the whole compilation process will be faster, and gives you a full correctness check before linking.
One thing is that all the code in the header files does get compiled in with the rest of the code which is why really big header files, or source code files with lots of headers take a while to compile since there's a lot of hidden code being analyzed by the compiler.
which linux distro u use and which ide do u use? thx!
Why did you have to set an environment variable at 7:37? Was the call to gcc at 7:20 not sufficient to make the association?
I don't think the gcc call is enough since lowlevelmath is a shared/dynamic library. During run-time you got to tell the link loader where to find all necessary shared libs. It's kind of like the PATH environment variable for libraries
No, because the add function was in a shared object (.so) which is loaded at runtime (dynamic linking). Later in the video he uses .o files (static linking) so it's not necessary. He kinda glossed over that bit.
How dynamic libraries such as *.so / *.dll are found is kind of platform specific. e.g. in windows DLL's are automatically searched in the application folder and a bunch of other folders (super unsafe. google dll injection). On Linux you can embed a "RPATH" into your executable that tells linux where to find the *.so file or you use the environment variable as shown in the video. Note that this gets even more complicated: Android, iOS and co all use "rpath" but in very different ways.
Another interesting observation is that a C header file works as an "interface" type.
Whereas in C++ or Python "base class", a Rust trait, or a C# interface, in C you have .h files.
It describes any object types (structs with or without typedefs) and the (virtual) procedures that are available in the module.
An accompanying .c file or Feature Test Macro (for single-implementation header files) can be added to choose the implementation.
This way, a .h file can define a bunch of functions, but for instance you could implement one .c file per platform. The .h file is the abstract class/interface/traits, the .c file is the derived class/inteface implementation/impl.
C was data-object oriented driven from the start.
Is it possible to do dynamic linking without having a copy of the .so at _compile_ time, only based off metadata?
Your demonstration and explanations are superb. You've given me a strong mental image of how the process works. Thank you!
When I was doing C I used unity build. Instead of using header files I just included .c files directly. I had my main .c file that had the main loop, and included all the other files into that. It worked beautifully. This method has a downside and an upside. Downside is that you can't tell what each file depends on. The upside is that you have to figure out how to avoid a circular reference, which makes your code more disciplined and organized.
damn! continuity error at 1:33 (the name of the .o file changed 🥲)
how does this relate to run time? Where the compiler would compile your code into run time code? Such as a PE (windows executable) file.
In Windows, the obj files created by "gcc -c" that he mentioned at the very end are just called .dll (dynamic link library) files. Everything else is almost identical, AFAIK (and I don't know much).
"Returns a Client Star" instead of saying a pointer to a clients struct. This is how terror of pointers starts
9:45 You can compile it in easier method in one go. Instead of creating separate objects, give a gcc all the .c (and .o) files.
Video was great. i was just trying out rust FFI and i don't know much about c. and i came on YT and found this at top. Thanks
pls make a video on kernel headers.
Its so that the compiler can see into the future and was necessary in the early days. Nowadays with lots of ram it could just make multiple passes. You do spend an inordinate amount of time dealing with linking errors especially when you grab something off github so its now just there to annoy you.
Okay can we link functionality over different computer let's say add stay on server A subtract on B and I am calling them on server C.
In java we can do it using rmi.
And in c I tried using callback function binded to target command enum.
Any other way?
Please remember 40 years back making it easier for computer to compile was extremely important. I remember old grumpy programmers complaining about inefficiency of high level languages (C)
Object files should technically be shipped by closed source software that embeds (rather than link externally) LGPL code so you can compile and link your own copy of the LGPL code, but I'm yet to see anyone do that.
I see headers as a public API which other files include which can be parsed across many TUs (where as a static symbol in a header would be copied to each TU) and C files as private symbols limited to a single TU. Using header files correctly leads to less code bloat and imo more consise less complicated code. Also, for an example, you cannot use a variable across many files without an extern in header and one source file including that header defining that extern. Improper use of header files leads to massive code bloat and its just not nice to see.
ok but where do i get this shirt?
That shows how they work, but I never really got why the compiler didn't just handle all of that to begin with. Why is another file necessary when it's just duplicating code that was already written? Wouldn't it make more sense to DRR?
I am currently porting some stuff to rust that uses a headerfile that you are supposed to include multiple times, changing other state betweentimes so that you can declare multiple versions of a struct. This is pure insanity and should never have been posible.
Where can I get this T-Shirt?
Headers are basically here to make compiling easier. They're a remnant of the past that stuck around.
You see, the early C compilers were dumb so if you tried to call a function that was declared later on in the source, they couldn't find it. Sometimes you could solve this by shuffling the functions around, but sometimes it didn't work when the functions depended on each other. (e.g. Function A needs to call function B that in turn either calls Function C or function B again in some recursion scenario).
To solve that dumbness of the early C compilers, the header files were invented where all the functions would be declared beforehand so the compiler won't think that a function that exist, doesn't.
Nowadays, the compilers such as GCC and MSVC are actually pretty smart about declarations and can find the function that was declared later on in the code, but the header files stuck around.
“I trusted you but now your words mean nothing to me because your actions spoke the truth.” -Linker
I mean, I guess it makes it easier for the linker. Also organizes your code a little...?
My professor told me that back in the good old days it would take a million years to compile code and having headers meant that you didn't have to recompile code that hasn't changed a million times.
c is powerful
very good for understanding the inner workings of almost everything
Yeah, I still use C++ for autogeneration of vtables, destructors, passing around 'this', and clean smart pointers, but C feels like the king of languages. I like how straightforward the translation to assembly is. You can have the compiler output .s files to see exactly what it did, and it's usually pretty much the same as the C code, just with all the register/memory juggling done for you.
Couldn't you also compile all the .c files in order to not use that flag? Or is that possible just for C++?
What do you mean???
Yeah, you can just gcc main.c mylib.c as well
(Probably slower because you will recompile everything every time)
@@rodolphov.santoro8829 oh ok I didn't know it could be slower thx.
@@MI08SK what the guy on top just said
Is this not high level learning? 🤔
Great content - love it!
yeah... and with jokes aside, I start to wonder why low level programming isn't called high level lmao
@@DeveloVooshGWebThen what would you call high level languages? Lunar languages?
@@EdKolis Idk about you dude, just basing on difficulty
@@DeveloVooshGWeb it's not based on difficulty, it's based on level of abstraction. High level languages are called that because they're at a higher level of abstraction.
@@EdKolis Aware of that, just don't know why it isn't based on difficulty instead. It can be confusing to navigate.
Pretty fucking awesome. I've already knew almost everything but you just explained so good that even a monkey can undestand that.
Nice video. Maybe you do some videos about this topic in general in the future, so I have some constructive criticism (even if it was a while ago). If you don't, then maybe these points will shine some light on things for other people:
- you could mention, that a #include directive really does what the name tells you: it INCLUDES the file after the "#include" in the file, where the '"include" is. This means, that it COPIES the entire file into your file. I personally find this (in my opinion very smart) solution to the problem of declaring functions quite interesting.
- you could SHOW some assembly created without optimization. On the one hand from the .obj files, on the other hands from the linked executables/libraries. When I saw that for my first time, a lot of things got more clear for me.
- you could somehow illustrate the ACTUAL linking of symbols (and what does "symbol" even mean? 🙂 ). Maybe this is somehow a difficult topic, nontheless very interesting.
- this last point is also a good cliffhanger to go IN-DEPTH on how the CPU really "executes" functions. How do parameters work, how does the OS and consequently the CPU "know", what to return to where, and what to take from where to what as arguments?
To be honest I really like the video. However the title is clickbait or just plain inaccurate. You explained how they work, but not why they're there. Please rename it to how header files work or something similar. All of what you talked about in the video is solved in modern languages without the use of header files and I feel like this topic could really be made into a much more in-depth video.
Yes. I watched the whole video waiting fior the "why they exist" and it never came.
I think explaining how the compiler isolates compilation units is sufficient. He is explaining "why?" in the context of "why does the compiler need header files?". What you are looking for is "Why was the C and C++ compiler designed with those restrictions?" but that is another topic, and one concerning a more historical perspective. Also, now that you know of these restrictions thanks to him, you can look it up!
This is one of those videos with really clickbaity names, but real content!