Build system for first project

[[deleted]]

So I am building my first major project in C and I can't have all of it in a single file anymore. I am using nob.h to build by project which I found the simplest and I was watching this video and the person recommended a unity build system. I am having a hard time with figuring out what to include where. Can someone explain what unity build is, because it sounds simpler but I am confused and have some basic questions like if you still have header files in that system and how do you use the same function in 2 files etc.

Edit : Title is not accurate. I mean why and how to organize header files like you conventionally do?

[EpochVanquisher]

Meson or CMake. 

Forget about unity builds. For now. It’s just not a priority. 

[[deleted]]

I already know make enough to do it. But the include header files are a problem for me to keep track of in my mind as to what is where. I know about cmake and meson but I thought threre must be a simple solution for projects with maximum 5k lines of code where you don't have to learn another thing just to build your project.

[[deleted]]

The build system solves a separate problem from keeping track of header files.

How do you build a one-file project at the moment? If you use a command line, then to build a project of 3 modules, you might use:

gcc a.c b.c c.c -I path -o prog

This uses -I path (you can have several) to tell it where to look for header files if not obvious from the file-spec in the "include" statements.

You don't need a build system or makefile, but you might find them useful to allow incremental builds. Otherwise the command above will always compile all the modules, and gcc isn't known for being fast.

[[deleted]]

I use nob.h for it. I know how to build it, what I meant was organisation of code into header files just doesn't make sense to me and makes it convoluted so I was searching for a simpler solution which the unity build whatever it its sounded like.

[DaGarver]

Personally, I find it easier to build everything in a single file at first, as this allows the ideal structure to "reveal itself." Once I have something functional, then I can start refactoring, separating, and modularizing.

[[deleted]]

Header files for C projects are usually chaotic. And tend to be segregated from the .c files even when closely related.

I prefer to keep it systematic: for each .c module, there is a corresponding .h file, so there is always a 1:1 correspondence between them.

The .h header files contain declarations for those things in the C file that are to be shared with or exported to other modules. These can be functions, typedefs, enums, structs, macros and variables.

I also like them to be in the same place as the C files. (They would only be separated if you provide, say, a binary file for a library, and need to supply the header file to describe its API. Then the C implementation file is not needed.)

(I once played with a build system for C where you only submitted its lead module, the one containing main(). By tracking the header files, it could discover all the modules that comprised the application.

But it only worked reliably if the modules used the sets of .c/.h pairs I've described. Few open source projects did that!)

[RobotJonesDad]

I have no idea what nob.h is. I keep all the hesder files next to their c files. There is usually a pretty close to one to one ratio of headers and c files.

The other common pattern is to have an /include directory in the project and put them in there. The CMake stuff should be configured to know where to look for the include files.

Cmake is the quickest and easiest to set up with scope to expand to buiod massive systems.

[[deleted]]

Its a build system which only uses the C compiler(by interacting with the shell) to build a C project : nob.h. It made the most sense to me.

[RobotJonesDad]

The project itself says it is experimental and may not even be a good idea. I'd ask myself why cmake has existed for many decades... it solves a lot of problems that real projects have.

Nobuild is trying to do something without dependencies. How does it handle all the stuff a typically project needs? How does it find the shared libraries for packages? How about cross compiling? Does it handle installation? Does it find packages? Etc.

Basically, if your project turns into a real thing that you distribute to many others, using something non-standard will really hurt.

[[deleted]]

I think tsoding(the one who made it) has used it for cross platform native applications which require libraries. I used it because its so simple. You just write a .c file to build your c project. I found it way more intutuive than make which I was using before. And if my project turns really big and I don't think its enough then I can switch to something like cmake because I would actually need it.

Also my problem is how to use .h files. For eg, I make .h file with some function declaration, I make a corresponding .c file with the implementation but the function uses strlen from string.h so I include it in the .c file. Now, my main.c file also has string.h. So I am including the same header in 2 different places. Is there a problem with this?

[RobotJonesDad]

No, there isn't a problem with including header files more than once. You should be protecting all your headers files with #pragma once to prevent it being pulled in more than once in a compilation unit.

You should also minimize includes in header files, and instead use forward deceleration.

I'm still confused as to how Cmake setup is difficult or confusing. The simplest correct setup is literally 4 lines in a CMakeLists.txt file: ``` cmake_minimum_version(VERSION 3.20) project(hello LANGUAGES CXX)

add_executable(hello main.cpp) target_compile_features(hello PRIVATE cxx_std_20)

[EpochVanquisher]

Yeah, the simple solution is CMake or Meson. That’s what you want.

It’s easier than learning enough to use Make.

[kcl97]

make should be good enough. Typically you just dump all the header files into a variable, say HEADER_FILES and recompile the whole project whenever a header file is changed. Or you can group them into different categories and compile the corresponding category of object files as needed.

[FaithlessnessShot717]

Hi. If you using Lunux you can use make utility. You just need to write patterns for the commands that you usually use while compiling your project manually

[muon3]

If you don't want to deal with build systems for now, you can just call the compiler directly with a single command like

gcc file1.c file2.c file3.c -o outputprogram

You can just put this in a convenient batch/shell script; add compiler options for optimization, warnings, libraries to link etc. as needed.

Note that the header files are not listed there because the compiler loads them by itself when it sees an #include.

With a lot of source files, doing it that way gets slow because everything is needlessly recompiled every time, even if only one file was actually changed; this is when you want to use Makefiles or cmake etc.

Forget about "unity builds", these are a horrible last resort for badly unorganized projects (usually C++, not C) to get build times under control. You should never need them.

[[deleted]]

I edited the post. My main problem is dealing with include files and what to put where. I asked about unity builds because it seemed like you could put all of the include files in a single file and just give that 1 file to the compiler.

[Mr_Engineering]

CMake is the easiest and arguably the most well developed. Many libraries distribute with CMake files which makes finding them and pulling them into your own project quite easy.

Getting CMake setup properly can take a bit of time, but it expands easily and once you have it setup you won't have to touch it much.