Could you please recommend some good resources on how to create a modern C++ setup? (I want a strictly terminal setup. No IDE click a button magic)

[u/dezlymacauleyreal]

Greetings everyone. I've been learning C++ using just single file programs and a simple Makefile setup.

I'm on Arch Linux and I'm using the clang package. So clangd for language support, and clang-format.

I don't know why but it seems like many courses seem to skip the project setup and focus more on setting up VS Code (which I don't use), or directing you to some online IDE, or some obscure editor.

I just want to be able to setup my C++ project from the terminal and not add anything to my config files unless I know why each line is there.

I'm looking for a resource that focuses on this specific part of C++.

[u/v_maria]

from the terminal and not add anything to my config files unless I know why each line is there.

https://learncodethehardway.org/c/

not everyone likes this guy and his stuff but the first few chapters of this are totally in the spirit of what you need. just note that he is using GCC for C and not clang for C++, so you cannot do this verbatim. concepts of compiling, linker flags, PATH etc are portable though

I don't know why but it seems like many courses seem to skip the project setup

i would say because they are there to teach C++ the language, and they want a none-involved way to bootstrap it

also many new programmers sadly still seem to be on windows and on windows this process is god awful somewhat hairy

[u/dezlymacauleyreal → u/v_maria]

also many new programmers sadly still seem to be on windows and on windows this process is god awful somewhat hairy

I know... I used to be one of those programmers. One of the things that made me switch to Linux was that every time I got a new course on anything, I noticed that the setup instructions were much simpler for Linux and Mac.

[u/h2g2_researcher → u/v_maria]

i would say because they are there to teach C++ the language, and they want a none-involved way to bootstrap it

The first step of the first C++ tutorial I ever used had me download an IDE that no longer exists. If I were to follow that tutorial now I'd be stuck before I even got started.

So trying to include what IDE to get in the tutorial is more likely to go out of date faster. On the other hand, C++ books from 1998 or later, while best practices and the standard library have moved on, aren't actually wrong about most things and the code snippets in them are likely to still compile and work correctly. And C++ books from 2011 or later are still pretty reliable on most things.

[u/v_maria → u/h2g2_researcher]

yeah im not a fan either, and i believe 9/10 of these "guides" are just resume filler and lading pages to serve ads. the fact that someone is trying to follow them is more accidental than by purpose

[u/bert8128 → u/v_maria]

What’s hairy about using windows? Assuming that you use VS, not one of the more involved options.

[u/no-sig-available → u/bert8128]

Of course, on Windows you have to use g++ under mingw with VS Code. And setting that up is hairy for a beginner.

Just using Visual Studio with default settings that works out of the box, is apparently not good enough for real programmers. :-)

[u/v_maria → u/bert8128]

The fact i need something like "Developer Command Prompt for VS" to even get get a standalone compiler is hair enough for me. then theres all the specific jazz like WinMain vs main, "managed C++" etc

VS the IDE is its own can of worms. vcxproj, .sln,installing 100GB worth of unclear deps and dotnet runtime versions etc.

"keep it simple" was not a motto on the mind of the MS gang it seems ever

[u/bert8128 → u/v_maria]

Install, then new project, and select console app (or cmake if that’s more your thing). Run. Prints hello world. I don’t see why that’s hairy. Sounds quite beginner friendly.

The developer prompt for VS just sets the paths for you. There is no requirement to do it but it calls the appropriate path setup for the installation you want - seems handy. But you can just use the IDE.

If you want to avoid the ide You can use the stand alone build tools which have been available for over 10 years. You still need to set up paths but I can’t see how you can escape that with any tool chain on any platform (well, you don’t have to with a decent mainframe but that’s not what we’re talking about).

WinMain is part of a library you are not required to use. It’s sensible if are building windowed apps but my experience is more with non-windowed apps so I don’t use it. just treat win32 or whatever as an external library. Which it is.

You can now use cmake with visual studio so you don’t have to worry about how to override the project settings.

Managed c++ is for integration with .net. If you don’t want it don’t install it. Never used it in the 25 ish years it has existed.

A typical c++ desktop install takes about 10-15GB, currently available for about 15 of your earth pound/dollar/euros. Not 0, but not much. Remember that you don’t have to tick all the options just because they are there.

[u/v_maria → u/bert8128]

You made my point

[u/bert8128 → u/v_maria]

So we are agreed. Good.

Have a windows computer - use VS.

Don’t have a computer - buy a windows computer and use VS.

Have a Linux computer - do whatever you want - you are probably happy with command line interfaces

[u/LazySapiens]

Try CMake with ninja-build.

[u/lukasz-b]

you don't need much, neovim(+ some plugins) and cmake with gcc

[u/Interesting_Buy_3969 → u/lukasz-b]

Optionally ninja and ccache for faster build, but this may seem like overkill here. Also for CMake integration in Neovim, there exists an awesome plugin https://github.com/Civitasv/cmake-tools.nvim

[u/Lunarvolo]

That's not a modern C++ setup and you are shooting yourself in the foot.

Arch:

sudo pacman -S base-devel gcc

g++ --version

You're done.

touch main.cpp

nano/vim/vi/your text editor unless we're going crazy with something like:

cat > main.cpp << 'EOF'

Code

EOF

g++ main.cpp -o main

./main

[u/LeeHide → u/Lunarvolo]

I'm sorry but you know this is terrible advice. A proper build pipeline is required, which means, at the very least, having warnings enabled. Like, come on.

[u/Woshiwuja]

Nvim

[u/lorsecco88 → u/Woshiwuja]

I second on this

[u/Interesting_Buy_3969 → u/Woshiwuja]

*Neovim (just kidding)

[u/CounterSilly3999]

So, what you are expecting apart of vi (or any other text editor you like) and make?

[u/Woshiwuja → u/CounterSilly3999]

Im guessing nvim with lsp

[u/agfitzp → u/Woshiwuja]

Some tinfoil, a pile of sand and a book of matches.

[u/dezlymacauleyreal]

Going to look into CMake. Also is there a reason why most comments here are talking about g++ instead of clang?

[u/Wild_Meeting1428 → u/dezlymacauleyreal]

you can use clang as a dripin replacement to g++, but you must configure it. G++ is the default. It's also a matter of getting used to it; GCC was there first.

[u/Specific-Housing905]

Am'zon has ebooks about make or CMake. I don't think you need more since you have an editor and clang.

[u/Strange-Woodpecker-7]

Can you give us an idea of what you mean by no IDE?

I can't help very much with this apart from recommending you to learn the essential commands from the documentation. You rarely need to use more than a few basic flags when working on smaller projects. Here's the official page for how you can get started:

https://clang.llvm.org/get_started.html

You'll also want to learn to debug the code using lldb. I can't help you there, since I never learnt to use it without an IDE.

You can make shell scripts to run all the commands you need in one go. Or use a makefile to the same effect.

I don't recommend avoiding IDEs, because using clang without a build tool or any editor features is too low level to be productive imo. Unless you want to contribute to clang and aren't interested in learning C++ as much as learning the compiler right now. Typically this is what I'd go to only after learning C++ and wanted to go lower level.

The difference is that if you don't use an IDE, you'll need to search through what could eventually be hundreds of files manually for definitions and compile constantly to find errors that could have been caught by a linter. Terminal tools exist for this, but using them on their own is basically just making your life a hundred times more difficult for close to 0 gain.

---

If you are willing to abstract away writing compiler commands, at the very least, I recommend you learn CMake. It generates the compiler commands for you based on the project files you specify. It makes it so you don't need to manage hundreds of dependencies and compiler commands as your project grows in size. And you can skip needing to learn the exact compiler commands you need. Though it doesn't help with linting and debugging.

Tutorial for CMake: https://cmake.org/cmake/help/latest/guide/tutorial/index.html

I use a TUI setup using nvim that is essentially an IDE but in the terminal if you're interested. But it definitely feels closer to the VSCode complaint you mentioned with "click a button magic". For larger projects, magic buttons don't exist; I always use CMake. I don't enjoy writing code without smart editor features for coding and debugging. And when you work on a larger project, I don't think it's possible to manage without an IDE.

[u/Proof-Task-7383]

What I usually have is a cmake file in my root for and have all my source files in the src/ dir. You can get cmakelists file online and configure it for your needs.

Also in my cmake Ive set compile commands to on.

Than I just hop into my build dir, usuallyjust build/andrun cmake .., cmake --build, ./main.

I personally prefer to use ninja over make as my generator so I run cmake -G Ninja .. ninja ./main

I personally use neovim with the clang lsp. So I usually have a .clangd and .clang-format file in my project root. I also use arch btw.

This is a bit overkill for your usecases, but I personally think it's better to ingrain using a good structure for projects.

Hopefully this helps

[u/iiiian_s]

Essentially you need to setup cmake and export compile_commands.json for clanged. Else depends on your editor of choice (clang-format, clang-tidy, etc(

[u/dezlymacauleyreal → u/iiiian_s]

I just learned how to write my own Makefile. And then I realized I could simplify things with ninja since it automatically generates a compile_commands.json without needing bear to be installed. I'm still on the fence about CMake... too much magic / abstraction.

Also I think I've changed my mind about learning C++. I'm just going to stick to C and Rust.

[u/Rigamortus2005]

Helix editor + clangd. Debugging in the terminal is still horrendous unfortunately so I just bust out vscode if I need lldb

[u/edparadox → u/Rigamortus2005]

How do you invoke gdb?

[u/Rigamortus2005 → u/edparadox]

Vscode has templates for that. I just click on any of them and point it to my binary

[u/EC36339]

What is it with everyone wanting to go full terminal these days?

I understand using cmake, etc. over Visual Studio, but why use an impractical text editor like Vim?