sample2.txt

s and lots of options, lots and lots you can do. This should get you started.
And when you are having problems, come here and post your code. Be sure to format your code in a code block - the Reddit editor should help you with that. Try to ask as narrow a question as possible. That'll be hard at first, it's a skill you'll learn by trying.

Visual Studio is as good as it gets on Windows and is good for an absolute beginner as well. There's a lot of features in the development environment, but you can just not use most of it. Setting up and working with GCC (the other good compiler choice) on Windows is way more work than just grabbing the the VS Community edition and using that.

So there is a bit to untagle here. A compiler turns your source code into an exectuable. The IDE or text editor you edit that code is a different thing. It may be rather smart, using a compiler in the background, to give you hints on what is wrong while you type, give you contextual autocompletion and all the fancy things.
There honestly is nothing wrong with starting in a full fleged IDE. While it may be true that doing compilation and linking on the commandline do give you a bit more insight that really is nothing you should bother with until you got the basics. IMO its like learning how to build a car before you can even drive one (which is sorta lacking as an analogy, but i hope you get it).
On windows i would suggest to use Visual Studio (not VSCode), since "it just works". You select "new terminal application" and its all setup for you.
On linux its a different story. Installing a compiler and separate text editor is way more feasible. For compiler you have the choice between  gcc (or rather g++) and clang (or rather clang++), and it doesnt really matter which one you choose. For an editor/IDE you should def use something with syntax highlighting, for example VSCode or even just gedit. Another option would be KDevelop, which is a proper IDE, but would need more setup.
What you most def do not want to do is use anything like vim, emacs or any other terminal based text editor. You want to learn C++ and not an editor that will just be alien to you and not nearly as usefull.

On linux you could try qtcreator. It is a really nice IDE with or without using Qt.

https://sourceforge.net/projects/orwelldevcpp/ 
is what I downloaded a couple of weeks back, I'm in the same boat as you pretty much. I'm not too sure what to look for myself as I'm a beginner too, but it works great for me! Everything looks nice and as for autocompletion I've never really seen it work. Probably possible to enable it, but disabled by default

Start with VS Community. When you run into problems or you have questions, there’s almost always some solution or help online somewhere and MOST of the time that solution is using VS. 
There are other IDEs out there that work just as well. I use CodeBlocks. Why? My machine has to remain off network and because, Microsoft (I REALLY wish they would put out another edition that can install offline without activation). 
When you work with open source stuff you really have to rely on the community of developers that take a lot of their free time to work on such things for support unless you’re some kind of wizard. If you don’t really know what you’re doing (like myself), you find yourself stuck asking questions on forums where people just kind of push you off objecting to form. Or, sometimes they like to point out typos that really aren’t the problem and then tell you to go elsewhere. Kind of like that know-it-all kid from Polar Express. I should clarify, I’ve found that people on Reddit in this sub in particular haven’t had that same tendency. They’ve been way more helpful than other forums, so I think you’re starting in a good place. ;)
All of that being said, Eclipse is pretty good (I used it with Java for a class I took but haven’t used it with C++). CodeBlocks is pretty good (that’s what I’m kind of stuck with for my offline machine) and I’ve heard really good things about and would love to try CLion. If I were you I would go with VS if you can, just because of the disparity in the amount of online information you can find from people using it vs the other IDEs.

Visual Studio is really slow for me, so if you have almost no knowledge, use repl.it for low level projects. (It’s free)

The best ones are msvc and gcc

Start with the Nuwen distro of g++.
It's small and super-easy to install.
Maintained by u/STL.

Although you talk about the command line, you seem to think about the IDE.
In order to play with small C++ programs as you need to do when learning C++, you need the go through the following steps:

Enter and/or edit a text file that is the C++ program. You'll normally store the file somewhere on your hard disk. Let's assume it is called program.cpp.
Compile the file, by passing the name of this program file to a compiler. In fact, many steps are necessary: preprocessing : takes program.cpp and processes it by reading all included headers, replacing all macros and stuff like that. If the result is written to disk this probably would have the extension .ii, for example the resulting file could be named program.ii. The next step is the actual compilation done by the compiler. This takes the preprocessed file as input and writes out an object file, which usually has the extension .o. Aka, program.o. Then it is the turn of the linker that takes program.o and possibly other compiled object files, as well as libraries (.dll files on windows) and produces the end result: program.exe.
Finally you need to run the program. Simple C++ programs won't use Operating System depending libraries etc, but will just use the standard C++ features for I/O: reading a line or lines from the keyboard (must hit Enter key to be able to read it) and writing character strings to... the "console" (or terminal).

When using a command line, you will have a window open that IS a console or terminal. This gives you a command prompt from which you can start your favourite text editor for writing C++ programs. You can type in the command that does step 2 (usually everything is done with a single command). And finally you can run the resulting .exe from the command line too.
Personally I PREFER the command line. I use it exclusively, also for the most complex projects. Of course I do not type all the commands in again and again; I use self written scripts and shell aliases and functions to abbreviate what I need often and to make my commands powerful. An IDE does the same, but then has a button for each such function. The downside of an IDE is that it is less flexible (often you can't even choose your own editor, but it has that builtin). It is more integrated though, for example the editor that they force upon you is aware of C++ and program structure, allowing a visual way to navigate the program (and provide completion etc). It might write your stuff to hard disk in a more black box kind of way though, writing a "project file" that isn't really human readable: you will always need that specific IDE to continue (easily) with your project.
A GOOD editor (read: (neo)vim) can do everything you want, doesn't require a mouse (everything is done by keyboard, which speeds up production a lot (a mouse is slow), and saves you from RSI:p), but has a very steep learning curve: in the beginning you'll be learning for weeks just how to use the editor (And you'll never really learn it all, it's just too much). Plus, once you get USED to vim you won't want to use anything else anymore, which makes it thus impossible to use an IDE anymore ;). I speak from experience.
If you use a simplistic text editor then you won't need to learn how to use it, and it will be easy to start using an IDE later on (it just won't be as fast). If you plan on coding 8+ hours per day every day for years to come, I advise you to invest time into vim though.
The command line compilers are basically all the same (as long as they are command line): it either works or it doesn't. The IDE will call the same programs, it will just do it behind the scenes, hiding all the details from you. That is fine, just click with the mouse and it compiles and probably even runs too, as long as it works. If anything goes wrong you won't have a clue what that is. Hence, getting practise with the command-line yourself is the way to go to become a wizard - also an IDE wizard.
I use only linux, and I'd say: use g++ or clang++. Those also exist for Windows, but I'll leave it to windows people here to advise maybe something else.

Dude, I have bee. stumbling around inside visual studio solutions and c++ for almost 4 months now. I came from python on a mac OS sooo.... lots of new.
This cleared up a ton of the VS side though. Thank you!!!

Thank you so much for this in depth tutorial. I download VS and I backed away from it because it seemed too complex. I'm definitely going to give what you suggested another go now :)

I take minor issue with the last paragraph. It's not important if you are learning this as a hobby or expect to get a job where they are paying for an IDE. Otherwise, it's worth the time to learn a CLI editor as well so you can do your job. 
A lot of my job is on CLI, and the only way to learn it is to use it and pick up pieces as you go. I don't think I'm at the one weird company where CLI is still heavily used.
Basic vim/emacs is just a couple days of use.

QtCreator is a good choice on Linux if you want something "that just works". Similarly to Visual Studio you can select "New console application" sand everything is there for you, including a cmake script.

Another good IDE is CLion. At least on Linux, it just works (once your compiler is installed, of course, but that's just a single terminal command on Linux). It's a good idea to learn C++ on Linux to start with since the support for C++ on Linux is so much better than it is on Windows. Of course, you can do everything on Windows that you can on Linux with C++, it's just usually more annoying.

Thank you so much for interpreting my question and clearing a few things up :) So as I understand. A text editor/IDE is the actual thing you use to write the code? And up to this point the "code" is just written text, that a machine can't do anything with? So the compiler takes the this " english code" and turns it into some kind of binary that the computer/machine can execute? 
​
So further more I understand that you can have the editor and compiler separate(easier on linux), where as something like Visual Studio is a "package deal". 
After reading this thread entirely I can't help but be intrigued by Vim and Emacs after hearing about it. Should I definitely stay away from this as a beginner?

It's a tiny bit irrational, but I loathe devc++. I also loathe geany. More problems than solutions, in my experience.

All taken on board. Visual Studio is definitely coming up a lot so I think as you said its probably definitely the best place to start with :)  I have heard of eclipse and codeblocks, I may have a look at these but as you said, as a beginner you need as some resources as possible to help you along the and VS ticks that box. Well I have definitely had a good first impression on this sub :) hopefully I can help people when I start to get to grips with it :)

I like the way you think. Except for all that stuff about vim. You obviously meant to say emacs.
A command line interface is way better when you're learning in order to get a better understanding of how things work in the build process. And more powerful and flexible in general than a gui once you do know what you're doing.
A basic class in using a shell and its core concepts should be part of any programming curriculum. See so many questions caused by, say, not understanding what a current working directory is...

I must ask, have you ever used an IDE?
You are aware you dont have to actually click buttons? Keybinds do exist. KDevelop even has a "enable vim keybindings" checkbox that i fear to enable.
You also are aware that an IDE is not a compiler, but infact a text editor with integrated development features? So that comment on it "forcing an editor on your" is pretty redundant. An IDE is and editor.
You also are aware that IDEs exist to integrate the compiler and its output into your editor, so you can e.g. click (yes, sometimes that is the better option) an error message in the compilation output and it takes you to that line? So im not sure what its "hiding" from you, that you cant find out what went wrong.
You also might know that you can (and should) use CMake, which your IDE then loads, so you are not tied to the IDE at all. Ofc your ide has to stores its own meta information somewhere, but that is not required for the project itself, its information about your setup on this machine.

Really interesting stuff. You've really intrigued with this. I'm not conflicted wether to go down the IDE route or as you say the vim route. I really do like the idea of learning and understanding everything thats happening under the hood. I do have a tendency of picking the hardest way of learning/doing things but that's always better and pays off in the long term. You mentioned g++ or clang++. Is this the vim that you mention? (0command-line)

No one should suffer for 4 months. This sub is much nicer than SO, so don't be afraid to ask. There are VS users on here, someone will be able to guide you through how to setup your next thing.

I don't think I'm at the one weird company where CLI is still heavily used.

I'd beg to differ tbh. Using a terminal to compile/build is obviously fine and all and yes, people should definitely learn how to do that, but your comment strongly suggests that the entire work is being done in a terminal only. Which implies you have no graphical interface on your OS. And I'm sorry, but that doesn't sound like any normal (work) environment at all. Even in the few scenarios where you run code on a system without a graphical interface you wouldn't do actual coding on that system but rather do that on a normal machine (either by transferring files or via SSH or something similar). What kind of job are you talking about?

Note that this post is me agreeing with you /u/sweenish182. Sorry for the rant.
Vim is fantastic and seems to get a lot of hate in this sub. I work in/on what is understood to be the world's largest monolithic software repo (not a toy project), and I am not alone at Google in preferring vim (not by a long shot). In fact, they have a stock vimrc that is really well tuned to our environment as a starting point.
When forced to use an IDE, the first thing I'm looking for is vim mode (and I'm very judgemental if it sucks [e.g., no support for macros]). With vim, I have code completion including parameter annotations and function comments, can jump around (e.g., to symbol decl or defn), etc. It works fantastically for me and many others.
The point I'm trying to make here is that terminal (or console) people are a thing--we work in all levels of industry. I am one of those people, and we are not even rare.

A text editor/IDE is the actual thing you use to write the code?

In principal, yes. Nothing stops you from writing your code in notepad (apart from your sanity ofc). An IDE is more than that. It interfaces the different parts of development together, giving your access to the compiler and its output from within the "editor", allowing you to debug and stuff.

And up to this point [..] can execute? 

Correct.

So further more I understand that you can have the editor and compiler separate

Yes. These things, just like the term IDE, are not as clear cut. Usually editors and IDEs are developed by separate entities.
VS also has a bit of a special role here. You can use VS without the MSVC (the compiler) that comes with it, and you can use the compiler without VS, but really VS as an IDE is way to good to do that.

Should I definitely stay away from this as a beginner?

Starting off in a command line editor just adds a step to the learning curve that doesnt get you anything at that stage of learning. Would you rather be confused by how to navigate your editor, when you already are used to just being able to click where you want your cursor to go?
Personally my advice would be to avoid these things (like the plague, which btw is fairly well treatable...). Do not actually develop in command line editors. You should know how to use them to a certain degree, just in case you have to. But in the end modern tools are 1) superior if mastered to the same degree as any command line editor buffed up with a dozen plugins (at that point its just an IDE in the command line anyways) and 2) way easier to get into and setup.
That doesnt mean you shouldnt have an understanding of how compilation and linking work, but thats like learning higher forms of poetry before you can speak the language.

Sure, why? For me it works fine

Thank you ;). And yeah, the old emacs <--> vim war is fought with a chuckle between friends. I never used emacs at all by the way, so wouldn't have an idea. But the generation brought up with Windows, who indeed don't understand what a current working directory is, ... The difference between CL and GUI is just too large. Different worlds imho.
PS, if you are using linux and bash, you want to use my cdeh system ;). You REALLY do. https://carlowood.github.io/howto/cdeh.html

Per paragraph,
yes - that is, I tried them out and they did NOT offer to use vim. There is no such thing as vim-keybindings imho (although at the time I tried these IDE's they didn't even offer that): if you want vim you want all of it.
Of course, but reaching for ctrl-shift-F11 is still harder than what vim offers. I find key bindings that use control, shift, alt, super or the F* keys hard (slow) to use, too, although not as slow as a mouse of course, but we're talking about jumping back- and forwards through the text, selecting text to move it around, things that are used too frequent to spend half a second on.
I can do that with my "command line" setup too. Of course it is a crucial feature to be able to quickly open a source file at the place of an error that the compiler just spewed. And so is being able to jump directly to the declaration or definition of whatever is under your cursor. Vim doesn't have that built-in, but it is so extendable that you can use other tools to support it (I'm using ctags). It might be harder to set up, but it is also more customisable as a result I think.
I guess I have indeed not enough experience with IDE's. But the fact is that that is because every time I tried them, I hurried back to the command-line. The main reason being that I can't work (efficiently) with another editor than a full-blown vim (now using neovim). It SHOULD be possible to ACTUALLY support that imho (although I read that one of the reasons for neovim is to make this possible, so apparently it wasn't with plain vim). The second reason being that I want a separate window for everything. A single window that got split into a lot of little windows is like an application that tries to be its own window manager?! Not to mention that I don't need all that "info", it just takes screen space :/. I think that it is possible to write an application that should be called IDE and does exactly what I want, but I haven't seen any yet that comes near that (last time I checked was 10 years ago or so, so maybe things have finally improved).
Bottom line, I don't think that an IDE offers anything except a menu and other clickable things to "configure" your project (Aka a GUI). I have never had a need for that though (plus I hate menu's). I configure my projects in (text) files that I edit in vim. It is certainly true that my setup is something that has grown over many many years, not something a newbies could to set up in a week (unless I'd write a HOWTO, then it shouldn't be a problem to start using this system).

g++ and clang++ are compilers, they come with preprocessor, assembler and linker too.
For larger projects, that is, anything larger than a single source file that You'll start with for the earliest learn cpp cases, you also need a "build system", this is the part keeps track of which files need building (generating, which includes compiling .cpp sources) and how, in what order etc. So you can just say ok "make" the project, building everything that needs (re)building. The build system is often very complex, so much so in fact that you usually generate it.
Anyway, I can only tell you how this works on linux :/. Here, next to configuration files, one can use environment variables (although also these are often given a value in some file of course) and command line parameters to tell the build system generator how to generate the build system, then to tell the build system (additional) how to build the project, and finally tell the created application how to run.
There are many build system generators, but the industry standard is currently pretty much cmake; there is also "autotools" which has its roots in pure UNIX (or rather POSIX) and therefore a lot less suited for cross platform building (it is possible, but harder to set up and maintain). Also, autotools only support 'make' (and Makefiles) as build system, a single-target build system (where target means "build for debugging purposes" or "build a release version" etc), but there are more build systems, also multi-target ones (here you'd tell the build system (when building) if it has to make a debug version, a release version or both), and cmake supports those too.
Calling an IDE an editor is incorrect imho. An IDE tries to integrate everything: the editor being built-in I guess (because of the extreme integration that is necessary) but at the same time it provides the GUI to configure the build system generator (still cmake, or the likes) and fire that off from within this GUI. I am sure it provides as much sane defaults as possible, while also allowing to configure everything differently. It can even provide the terminal that your application runs in (Aka, intercepting its output and then displaying that in some window of the GUI).
The CLI (Command Line Interface) route keeps everything separated and doesn't provide a GUI to wrap all of it and make it look like a single application. You'll need the following things eventually thus,
1) any text editor
2) build system generator
3) a console or terminal application to run everything in / from
You should probably start with being the build system generator yourself (aka, don't use one, type it yourself).
If your pick for build system would be "Makefiles", then that means you'd have to write a little Makefile. But, before doing that I'd start with executing the build commands yourself even from the command prompt.
It would be nice if your text editor supported syntax highlighting and allowed you to quickly navigate around all the sources etc. That rules out most text editors. While vim can do almost anything, most of it needs manual configuration (I'd like to get that .vimrc file that Google is using, as another person said here). I wrote a HOWTO how to get TrueColor syntax highlighting with vim using custom colors and patterns (I'm even using ctags to generate syntax highlight config stuff).
So, using vim, cmake and having a terminal with shell and command line open, a typical edit/compile/test cycle would look as follows:
$ cmake -S . -B build   # generate build system (Makefile's)

$ vim program.cpp       # make changes to program  
$ make -C build         # compile/link program  
$ build/program.exe     # run application; afterwards go back to 'vim program.cpp' to repeat cycle.

But your commands will instead look like this at first:
$ vim program.cpp       # write / change program code  
$ clang++ program.cpp -o program.exe   # compile/link program  
$ ./program.exe         # run application and repeat.

And only once you get tired of typing the clang++ command learn how to use a Makefile. And once you get tired of writing those, learn how to generate them with cmake.. And once you know that, consider using an IDE to integrate it all.

One where the code is is on a server that you ssh to only after connecting to your remote desktop which can only be done after connecting through the company VPN. That's not to say I don't use a GUI editor, I use VS Code 90% of the time. But that other 10% is vim, and all my git stuff is CLI (we don't pay for a GUI git client, we have smartgit. I hate smartgit). All build and test commands are 100% CLI (scripts invoking build containers and all that jazz).
I will be the first to admit that we could do with some more modernizing (but we do have some great CI/CD infrastructure), but so could any company that's been around for a while. 
We are at least using C++14, will soon be investigating C++17, and I am leading the charge on making clang tools more prevalent in our day-to-day, starting with clang-format. 
Most of our devs still proudly use vim, and they're only lacking a couple features when it comes to linting. ctags are stupid powerful. This being a sub for C++, I'd expect more than you think still do a LOT of work in CLI land. 
Also note, I'm not in full disagreement mode here. It depends on what the goal is. Just for fun, hobby, etc., I think you could safely ignore the CLI. But if the goal here is an eventual career, you need to be competent with a CLI. Expert, master? No. In the same way that I don't know how to do everything in MS Word, I don't know how to do everything in vim, but I know enough to edit a file and do basic operations. And being able to put both on a resume beats one, especially if that one is just a GUI.

No auto-completion but it works fine? Sure it does.

Forgive my cynicism, but you are one of these people who turned their command line and command line editor into an IDE with a dozen plugins, scripts and whatnot, but now tell people that IDEs aren't the way to go.

they did NOT offer to use vim

Again, an IDE is mainly a (smart) editor. What would "using vim" inside another editor even mean???

if you want vim you want all of it.

That may be true, but very obviously is only an argument for people well versed in vim. I dont even know what "all of it" for bare vim means, i dont think its a lot. The same probably applies to most command line editors.

Of course, but reaching for ctrl-shift-F11 is still harder than what vim offers.

What exactly made you stop in the settings right before opening the keybind menu? Thats a thing, right? And as you rightly point out shortcuts like this are too complex for common things - which is why that most likely is not the shortcut for e.g. "build".

I can do that with my "command line" setup too.

See my comment above. The point of the IDE is to not require any setup for this. It will simply build a syntax tree of the project and be fully aware of anything, without needing to add plugins or tags.

But the fact is that that is because every time I tried them, I hurried back to the command-line. 

Again, nothing wrong with that. But as is clear by now you did spend a lot of time doing setup and whatnot and most crucially are used to your personal environment for a long time. A start in bare vim is about as good as a start in bare gedit or notepad++. Hell npp might be better since the never versions actually know c++ and can autocomplete.

A single window that got split into a lot of little windows is like an application that tries to be its own window manager?!

Taking Kdevelop as an example, you can detach all parts of it. It also starts in KDE so make of that what you will xD

Not to mention that I don't need all that "info", it just takes screen space 

Then maybe, just maybe use a fraction of the time needed to add plugins to vim to just remove toolviews from the IDE you dont want to see? I fully agree its stupid every editor has a big fat "Save" button in the toolbar, but that doesnt stop me from just removing it.

Bottom line, I don't think that an IDE offers anything except a menu and other clickable things to "configure" your project (Aka a GUI)

Again, which the exception of VS and their solution files (and i guess there is a way to use these without VS), there the build system/project configuration has not much to do with your IDE. I can setup a CMake project and use it without KDevelop/CLion/VSCode/... But i can also import the project into my IDE and have all the features ^TM without any setup required.

So in the end we are around at not starting out with command line editors, because those would add a step to the learning curve that just doesnt need to be exactly there.
Sure its not hard and all, but its completly alien to anyone born after 1980. Especially when OP mentions word pad as a reference.

Ah that way, welp the guy asked for it. Good to hear it's not anything else weird within the ide, but I'll look for other options!

I once opened a file in vim. Couldn't figure out how to exit out of it for 30 minutes.

At the end, I landed on it depends. And my big caveat was that if you want a job, you should learn CLI. Hardly the same landing spots. Also, I was born after 1980.

The only reason I’ve ever used vim is because it’s the default editor that git shoves you into if you forget a commit message or have to resolve merge conflicts. I have to look up how to get out of it every single time.

rofl

I never said you shouldnt learn command line, or at least i hope i didnt. You most definitely should. Knowing the basics of a command line editor would be included in this. My point is that starting out in one makes everything harder than it really has to be.

I recently started using Visual Studio. The community edition is free

Qt Creator.

Take a look at Qt. It is free, very competent and supports multiple targets.

I like using GVim straight or an IDE with vi bindings.
It sounds like you are on a Windows machine. I would recommend to just use Visual Studio at the beginning, it will let you use a similar environment if you are interested in using any other of the languages it comes with.

Visual Studio works pretty well

I enjoy CLion. Can't comment on it much, though. I haven't used many IDEs.

Emacs.

Visual Studio 2015 :)

VS2015 because I use it at work.

QT Creator on linux for me after years of using Visual Studio on Windows.

[deleted]

Xcode. Simple and works. Visual studios has been a pita at times for me.

roxterm + zsh + cmake + (neo)vim + one or two shellscripts

Code::Blocks
But usually just go with makefiles
Xcode is better than visual studio, but it's on Mac which I only use for work so I find it useless. And in general I consider visual studio and xcode over bloated

vim with a load of plugins, most prominently 

youcompleteme (autocompletion)
omnitags (tags)
fugitive (git)
pyclewn (debugging with gdb)
Ctrl-P (file opening/navigation)
vimgrep

If you're on Windows, use Visual Studio. If you're on Linux, pretty much any text editor will do. I like Atom, though lots of people say it sucks for some reason.

Clion by JetBrains very intuitive.

Sublime is killer, but to be clear, it's a Text Editor, not an IDE.  Same goes for Vim/Emacs, Notepad, Text Edit.  IDE's typically restrict you to the language the IDE supports whereas text editors allow you to code more efficiently across all languages.
In Simple Terms:
IDE's are nice because of code completion
Text editors are nice because they make editing text (read code) more efficient.  Some allow for code completion too.

Bash.
That's right, I consider the command line to be an IDE (the environment that integrates my development tools).  It might not be for everybody, but it's certainly my favorite.

I use eclipse. Like any other tool it takes some time to learn before you can make proper use of it. Clion is also a very good IDE but you need a fairly new machine otherwise it may feel slow. If you like to compile the editor yourself you can try juci at https://github.com/cppit/jucipp.

Qt is the toolkit/framework. Qt Creator is the IDE.

+1 for vim or Xcode + Xvim

Hands down the most intuitive.

Me too.  
Whoever downvoted you can kindly fuck off.  Emacs has a great set of tools for programming in C++ (as well as C, Python, and various Lisps).
Edit:  downvoting people who reply to a question about which IDE they use to write C++ because they don't use the same tools that you use it simply childish.

Linux is an operating system designed around ease for developers. Getting a development environment up and working in Linux is trivial. Getting a development environment up and working in Windows is a dark ritual filled with blood and horror, even for experienced Windows developers.
But at the end of the day, each person will have the easiest time with the platform that they're most familiar with, for better or worse.

You may be the only person I've ever heard that thinks Xcode is better than anything at all.

can you debug in that?

The build tools an lack of debugger integration make it inferior to gedit, vim or emacs with the right plugins.

I can write code in emacs, compile it, run it, debug it, read documentation, interact with version control... it's an IDE.

How to you edit text?

Just curious, but could those with insigt elaborate on why it is being downvoted?

I can't deny that, no.

People are silly.

Don't take them for serious. Small children do that when someone else proved them wrong or said something that doesn't fit into their close-minded brains...

It took me longer to install OpenCV than to learn to write code using.
My $PATH is the biggest mess in the world right now. GOES EVERYWHERE!

Look, he's being a bit dramatic wrt setting up a Windows dev  environment, but once you understand Linux and the GNU tools, it really is a breath of fresh air.  The flexibility it provides simply cannot be matched by Windows.

I've long extolled the virtues of Xcode. In general I find its UI to be better than other IDEs such as VS. VS has been getting better over time though. Here's a post of mine that gives some examples.
On the other hand while I've had my share of VS crashes, VS has seemed to be generally more stable than Xcode.

Yes, fairly well. Clewn provides ex commands to control the debugger, like :Cnext or :Cwatch. 
You can bind those to shortcuts:
map &lt;M-n&gt; :Cnext&lt;CR&gt;
map &lt;M-p&gt; :exec "Cprint" . expand("&lt;cword&gt;")&lt;CR&gt;

It can also use buffers in windows as watch lists and such. 
You lose completion, I can't just press <tab> to get symbols autocompleted, but it works for me.

cool story bro.  good job reading their website.

GNU Emacs is an extensible, customizable text editor—and more.

It's a text editor just like Vim, Sublime, Text Edit, or any other text editor.  It happens to have features that allow you to do more than just edit text.  Still a text editor though.

ed.

echo and grep are all friends you will ever need (ok zsh too because bash is no fun).

vim, one of those development tools.

I can't tell if you're referring to Linux or Windows.
On Ubuntu, it's literally as easy as
$ sudo apt-get install libopencv-dev

All you have to do to get Visual Studio running on Windows is going to visualstudio.com, downloading the installer, then running and clicking through it. Then you let it work for a little while and that's it. That's how you get the, imo, best IDE out there.

You forgot the mandatory registration. It took me several hours to get through that process several months ago. As someone who has been programming for decades, this was immensely frustrating, especially when I was juggling multiple accounts at the time. If my sole living grandmother were to try this, she would have given up at the installer, if she managed to live through the wait.

Also, I guess I should respond to this:

Besides, all zach2good said is that OP should be using Visual Studio on Windows if that is the OS he's using.

I might have misinterpreted their original post. I thought they were saying that using anything besides the combination of Visual Studio and Windows is making your life hard for no reason. If your interpretation is what they meant, then I do withdraw some of the vitriol from my original post, but I don't withdraw any of the sentiment.

I never said anything about installing Visual Studio. Of course that's trivial. Setting up a development environment is entirely different.
Windows development is no big deal if you want to work with a completely monolithic code base, but I would argue that anyone with a modicum of self-respect should rather draw from existing packages, and because of that their projects will have multiple dependencies on third party libraries. Getting several third party libraries to work together and link together on Windows is hellish. I say "is" present tense, because I work on cross-platform libraries where I have to support Windows.
The dark ritual involves figuring out which mystical combination of /Md /MD /MT /MTd /LD flags you need to give each dependency in order for everything to cooperate. Or figuring out whether VS can't find your library dependency because of your $PATH variable or because of some project configuration variable buried deep in Settings -> Tools -> C++ -> Compiler Options -> Linker Settings then scroll through nested tabs and throw a dart at your monitor blindfolded.
Compare that to Ubuntu where handling dependencies is literally just
sudo apt-get install libname

and there's just no competition in the eyes of anyone who values their sanity.

I've had them both crash multiple times. Every time i turn on my mac at work and run xcode for the first time there's like 95% chance it will crash. VS crashes on random when i had to do some work for uni, mostly just putting code inside a vs project because they wanted it to be a vs project. 
I just don't like IDEs in general, usually they try to do too much when i need only one or a few things and thus, for me, it ends up an overbloated piece of garbage. Last time I updated the work laptop os, my xcode stopped working, then i updated it, then it started crashing and i had to reinstall it, that took me like 1-2 hours (because it weights like a fucking triple A game, not to mention that apple store is complete trash and can't download at full speed most of the time). When i had to install VS on my home pc for the first time it took me like 1 hour because my internet is slow and because somehow I managed to skip instaling c++ compiler. This shit is ridiculous.

What does an ide do that it doesn't?

Then the answer would be VIM not bash.

vim is my favorite editor when I'm on FreeBSD and Linux. But bash will probably not be what most consider an IDE. But I get what you mean. :-)

Windows.

handling dependencies is literally just

You can argue that in VS handling dependencies is Install-Package libname. Though that is just as multiplatform as apt-get (not very).

most IDEs provide built in templates for managing projects, creating test code, and other features related to programming in whatever language the IDE was built around.  Emacs, out of the box, with no configuration, does not compile, run, or test code.  You have to set it up to do so with add-on features.  An IDE such as Netbeans or Visual Studio come setup to do so out of the box.

No, it's not.  Vim is not an IDE, it's a (very advanced) text editor.  Though the line is blurred, since Vim can integrate with the compiler, build system, etc. to some extent.

There was zero feedback as to which account I was logged in with. Because of that, I ended up going through the registration process four times before I started over by logging out of everything I could find.
It turned out that there are three separate logins tied to a single account when you go through that registration process, all independent from each other, but changes in which are reflected in the first account you happen to be logged in as.
It's worse than Google's multi-account login, except at least Google shows you something you when you try doing something that affects the wrong account.

Sadly, Nuget doesn't have nearly the level of comprehensiveness that aptitude has. I would LOVE to have a comprehensive and reliable package manager for Windows. That would completely turn around my opinion of Windows development. But so far no one has been able to point me to one.

Comparing that to what you have to do on Linux

The Linux equivalent of installing Visual Studio is to download and install Qt Creator, so your followup post here is disgracefully hypocritical.
Qt Creator has intellisense, graphical debugging, valgrind, and a UI designer all built-in and completely free. It has everything that Visual Studio Community offers, in a much cleaner (IMO) package.
Or if you want to pay for a more advanced IDE on Linux, there's also CLion (although I personally would not recommend it, because I found it to be very slow for large scale projects).
Edit: Also, I should add that Qt Creator has far superior support for CMake than Visual Studio does, so that could save a beginner a hell of a lot of headache. And even better for beginners is QMake which is far and away the easiest build system to use (but it's admittedly very limited in terms of features, which is why I generally prefer CMake). Conversely, the Visual Studio .sln build system is the grossest thing I've ever had the displeasure of needing to use, and I say that as someone who has had to use autotools < shudder >.

M-x compile, etc.

I stand corrected.  Still not an IDE.

Without even trying it

So you're making conclusive judgments about things you've never even tried. I've actually used both, and I've found Qt Creator plus Linux to be an overall better development experience.
I won't deny that there exists "better" intellisense than what Qt Creator offers, depending on what kind of metrics you use. For example, CLion has far more comprehensive intellisense because it uses a stronger code model; in particular, it offers much more complete intellisense for templates than what Qt Creator does. But I don't use it because that stronger code model takes much longer to build up and causes the whole editor to do things slowly. I've run into this issue with Visual Studio as well, where the time it takes to parse the code model results in frequent hiccups which impact my productivity. So in that sense, Qt Creator's intellisense is better for me, because it's not as taxing and gives me what I need 95% of the time, which is good plenty.
Now you'll probably argue that beginners won't be working with giant code bases so that's a non-issue. And that's probably true, but that still has nothing to do with why I recommend Qt Creator for beginners. I recommend it because I find it to be an overall cleaner and simpler experience than Visual Studio. I find it easier to get going, easier to find all the settings you'll ever need to find, and more compatible with a wider range of third-party libraries (especially open source libraries, which is a main focus for me).

VS is widely accepted to be the best debugger out there

This is purely a matter of opinion, not fact. I've never struggled to debug difficult problems with the Qt Creator frontend for GDB, and I've never found Visual Studio to be any more helpful than Qt Creator + GDB.

I'm just going to stop responding now

I won't lose any sleep over this.

all you do, and did from the start, is arguing for the sense of arguing,

My impassioned arguments come from hours and days of accumulated frustration over getting basic shit to just compile under Visual Studio's terrible build system. If you haven't had to suffer through that, then I can only assume that you've never tried to put together a particularly complex project in Visual Studio before. Even just getting a Visual Studio project to link to Boost has been a headache on numerous occasions.

without even reading properly

I admit that I may have misinterpreted the original parent comment. Other than that, I think my reading performance has been satisfactory.

qtcreator

emacs does everything I need in an programming editor.

I really like KDevelop. Nothing beats it's highlighting and integration with CMake. I recently had some problem with it (due to a crash in clang) but otherwise it's a great ide.
I also tried QtCreator, which also have a great integration with CMake and it's recent integration with clang makes it even better (but suffers from the same clang crash).
That said, I've been told that as a power user, a good vim setup with the right plugins is hard to beat.
Edit: typo

I've been using CLion for the past 6 months or so. It requires a license and it's early days, so there are bugs. But it functions very similarly to IntelliJ which is hands down the best Java IDE on the market.

VS Code is fantastic.

+1 Clion.

I used to use Clion. It is good but it is not free for commercial and the licensing is yearly basis. Move to Qt Creator. Its free with decent tools and finctionalities.

CodeLite is an actively maintained and feature-rich C++ IDE. It's similar to Code::Blocks but easier to use and works better out-of-the-box. I used to use it for my C++ development but moved to VS Code with mixed success. I strongly recommend checking out both CodeLite and (for a less visual-oriented IDE) VS Code.

My recommendation - CLion. Its paid but if you are investing a lot of time developing in C++ on Linux then its worth it.

As already suggested, give VScode a try. It's pretty much Atom but more stable. I only used Atom for about 5 months last year and it felt like in pre-alpha, although it had a lot of potential.
Atom used to crash when opening large projects, as well as when adding some plugins. I think VScode have never crashed yet and I've been using it for about 10 months. I've even changed Notepad++ by VScode in Windows.
What I love about both Atom and VScode is the versatility they have adding plugins. You can configure them as whatever you want much easier than in classic IDEs (I've never tried CLion but people say it's awesome).
VScode is greatly integrate with Git, for example. And you want to edit some extra Python files? Just add 1 extension and quickly reload it to have syntax highlighting/error checking for Python.
Besides that (completely personal preference), I find the GUI very comfortable and really 21st Century, not like Eclipse for example.
The only thing I miss is more easiness in indexing files, although I have to admit that working with embedded I had terrible times configuring Eclipse in the past as well, and I blame the project structure more than the IDE in this particular case.

If you are looking for the best out-of-the-box experience, without any configuration necessary: CLion.
If you are willing to google a bit and install a couple of plugins and edit 1-2 config settings, then VSCode is a really good option too.

There are some options today, and you will get at least these, but even more suggestions:

Qt creator
CLion
eclipse CDT
KDevelop
VS Code with the C++ addon

You can try them all, a subset, or pick one and stuck with it, that's up to you
&#x200B;

You can pry Kdevelop from my cold dead hands. What a fantastic piece of software. CMake and gdb integration are just perfect, I've used it for years and do not really miss anything.
Before this, I used Qtcreator and that is a very comparable package. I prefer Kdev because it integrates well with KDE which is my DE, and I don't use Qt libs nor make Qt guis (when I do, I'll check it out again).
Quite frankly, I think Kdevelop is not very well known and quite underrated.

Hey man you might want to give Emacs a try. It has a steep learning curve, but it's something worth mastering. By that I mean you will be much more productive and will learn a lot more. Also vim is a good substitute, but Emacs is in my heart. There are a lot of tutorials all over the internet how to integrate Emacs with cmake and many other things to make your life easy. 
Happy hacking!

eclipse is very nice imo.

Eclipse CDT

You might want to try the lightweight C++ IDE juCi++. It is also one of the few IDE's that is written in newer C++.

I would recommend trying VSCode with cquery or ccls

For C++ look hard at Qt Creator (and I say that as a VS Code fanboy for non-C++ work).
It’s very subjective, though. VS Code, CLion, Qt Creator, Emacs ... try them all, pick the one that feels comfortable.

Nothing could beat Clion now. Otherwise invest your time in learning Emacs - be warned it is a life-long investment.

vscode + cquery

I used NetBeans and Eclipse. There's also Cevelop, build on eclipse (https://cevelop.com/)

cquery, a language server for C++ offers advanced IDE functionality to any editor that speaks its protocol. Many editors have plugins for it: emacs, VSCode, vim... I use kakoune myself.

I also use atom/terminal.  What's missing from it?

If you are using cmake, ive found vscode to actually be an excellent c++ ide on linux

Well to start out with there is one I can safely say you need to stay away form and that is Eclipse.   Eclipse consistently breaks itself and has done so for me on Linux, Mac OS and Windows.
You may already be past this level but it never hurts to learn to program using the command line and a text editor like VIM.  
As for IDE's and more advance editors you actually have many choices out there.  Examples:
Geany
Anjuta
Code::Blocks
EMACS
SciTE
These are not mentioned extensively here but worth your consideration.   
I should note that many of the free IDE's or advanced editors out there are very buggy in my opinion.   If you want reliability turn to software that has been around for awhile such as EMACS.

I really like SlickEdit IDE. It is very zippy especially with large projects (30000+ files) where I found using Eclipse was very slow. It does code indexing very quickly and I find it very easy to use and intuitive. And whenever have any questions about it the forum is monitored by the developers/enthusiastic users and they are very responsive.

Check out Visual Studio Code

codeblocks with the plugins package

Visual Studio 2017 remote development\debug\compilation

Atom, afaik, isn't an ide, it's just a very nice text editor with more tools
Try codeblocks or Eclipse, I'm loving em

also, don't use the QtCreator version in the ubuntu repos. Even in the latest Ubuntu releases it is fairly outdated. Use the official Qt packages instead : https://www1.qt.io/offline-installers/#section-11

Same here. I haven't found another editor that's as fast, has the features I want and also allows me to disable features that I find annoying. I have a customized .emacs file I've been carrying around with me since the mid-90's. There's surprisingly little in there, though. Mostly just a function to do vi-style paran matching in the editor buffer. I've used a lot of editors over the years, with my two favorites still being emacs and vi.

my problem with emacs is that you can program it. "I'll automate this with just a bit of this elisp". A week later I get back to what I was working on :)
&#x200B;
fwiw, I've been using it since the 80s. It's very useful and flexible.

emacs can turn off those attached to mouse interaction and those who want a ready, out-of-the-box experience.
That said, after putting in the time to learn it and customize it, it allows you to run circles around VS Code, QtCreator, etc..  
For intellisense look at cquery or ccls (forked):
https://github.com/cquery-project/cquery
https://github.com/MaskRay/ccls

But op is looking for an IDE. Can you debug with emacs? Editing is only half of the job...

[deleted]

Fellow KDevelop user. Both at home for Python and at work for C++.
Unfortunately clang seems to crash on our source files in any version above 5.2.0 for some reason (but only when running the appimage). I really want to upgrade though.

Could you elaborate on the vim setup? I’ve never heard of that term

I love KDevelop with its great array of plugins to help with productivity and catching bugs early on. One problem I have with it is the dark theme isn't the best and that there aren't a lot to pick from. It's low priority issue but I hope it gets fixed eventually.

Honestly, vim is not great compared to qtcreator. YCM requires generation of an extra configuration file to work correctly with headers as the compilation database is not sufficient, and you need a different tool like rtags to be able to follow links. Rtags can be restrictively slow on larger codebases though as it takes hours to index all the files. Clangd based plugins also rely on the compilation database which makes it unsuitable for jumping between header/source and interpreting headers in general. Qtcreator's interaction with cmake server mode and the clang code model make it more reliable than any vim plugin. The only advantage of vim is the key bindings which almost every IDE and code editor supports nowadays anyway.

What sort of cmake integration does it have?

CLion was going to be my recommendation. It has native integration with CMake which it uses for it's code completion. I've only made small networking projects using it but JetBrains git features are a godsend for simplifying the VCS model. It's worth noting I also use a Vim plugin on CLion/PyCharm/IntelliJ which is absolutely fantastic.
CLion is, as mentioned, a licensed product but it's free for hobbists.

I use Clion because I have an open source jetbrains license and I'm used to intellij and pycharm

I recently decided to give VS Code a chance. I find it less user friendly than other IDEs I've tried such as Eclipse or QTCreator.  Also not a fan of their "tasks" system.

I really love VSCode.
I've been using it from the beginning and the tooling has become so much better.
The CMake plugin (props to /u/vector-of-bool) has really matured and from my point of view covers most use cases.
cpptools plugin was a little hard to configure in the beginning, but now works very well and integrates nicely with the CMake plugin. Sometimes I have some performance issues with intellisense though (but that's on my VM).
Works even nice with SCL environments on RedHat/CentOS.

I've tried a few VS Code versions in the last couple of years and never managed to get the C++ plugins working, always had some issues with code navigation or bogus compile errors.

I know this is old. I tried to use KDevelop but it felt somewhat lacking and not as mature as other IDEs (or even text editors with plugins such as VS Code).
Just as an example, I want my editor to have a nice color scheme that I like, and KDevelop doesn't have many of those. There aren't many on the internet made by the community either so you're kinda stuck with what the IDE offers.
Also, I found the autocompletion a tad "bloated". Like, when I start typing it pulls out all sorts of symbols and macros which I know nothing about (I'm guessing from the standard library).
I switched to QtCreator after literally 3 minutes of use :/

+1
Investment in your tools multiplies productivity.

How does CLion handle new and/or complex Code ? Last time i tried it it had problems with code that is not trivial.

checkout ccls too. Which is a fork of cquery which makes use of C++17 features, has less third-party dependencies and slimmed-down code base.

Doesn't it run on Wine anyway?

Correct, atom can be converted into an IDE but all of my compiling is done through the terminal

Emacs supports mice just fine, and is ready out of the box? Only change I've ever made from the defaults are a keybinding to run the current buffer through clang-format.

https://www.gnu.org/software/emacs/manual/html_node/emacs/Debuggers.html
(That's a yes)

I want to like KDevelop, but I find the UI distractingly busy. QtCreator has one of the best UIs of any IDE I have ever used. I really wish it did the inline integration stuff that KDevelop did though.

We'll see with clang 7.0.0 how things goes. I reported the bug but if it's in clang, it's harder to fix and updates are show. Also, it's good to know which appimage works, thanks.

Vim is a very popular, and can be a very powerful, text editor. But, out of the box, it is only a text editor. There are numerous plugins to give it IDE like abilities.

Vim is a command line based text editor. It is known for being beginner unfriendly, but really powerful when mastered. I'm personally okay with graphical based IDE.

What do you mean the dark theme is not the best? I'm working using the dark theme for years! Here's a screenshot of my dark setup
I only selected the breeze dark scheme in the color theme, and tweaked a bit the color schema of the editor.

Vim is an editor, so we are not comparing apples with apples. But if the user wants IDE capabilities in vim, Language Server Protocols are the way to go. For c++ in particular, cquery has been working really good for me, including completion in headers. Clangd has a bright future, but not as mature as cquery right now (I tried a few months ago).  

The only advantage of vim is the key bindings which almost every IDE and code editor supports nowadays anyway.

Nah, not close to reality, try to see a video on how to use vim by a power user.

Well... The parsing is done correctly using the compilation database, there's also a full configuration and cache editor, and the whole project configuration is done through it.

You should try CMake plugin.

I have used both Qt Creator and VS Code fairly extensively, and can't think of a single advantage that Qt Creator has except for native integration of qmake and graphical .ui editing.

Its not IDE though

Try reinstalling them? I've never had this issue

Yea that's the thing I was mentioning - last time I tried it was similar, but it was 6+ months ago. It may or may not have gotten better since then - not sure!

I mostly work with legacy code, but so far it is doing well, recognizing lambdas etc.
Sometimes coloring is broken for a while on a heavy-templated code i.e. using boost::msm.
To format the code I'm using clang-format anyway, but build-in formatter works just fine.
Hints about unused functions etc are not always accurate but extremely useful anyway.
In general just give it a try, it greatly improved my productivity working with the C++ code.

Never heard about it, and will check it out today! Seems much more active then cquery.

Thanks, gotta give it a go for vs code.
Developer himself maintains AUR packages (tagged + git), very nice!

VS Code has native integrated terminal. Atom can have it via a plugin afaik.

I'm not sure what you mean, you're entirely in control of the buttons and panels shown at any given time.

Funny thing is that when used without appImage everything seems to work. Might be a problem with the packaging.

you can enable vi-keybindings in both qt creator and kdevelop to get a taste of it

You are vastly understating it's perceived difficulty, no other editor feels the same, it is super weird if you haven't been exposed to something like that.  I would highly recommend he watch many tutorials on VIM to get used to it

Thank you very much

The color scheme of the text editor isn't to my liking. I like softer colors that match closer to a material palette.

full configuration and cache editor

Full configuration editor? What do you mean by that? My laptop is Darwin and their Darwin release crashes looking for a library not included in the package, so can't check it out right now.

can't think of a single advantage that Qt Creator has 


Code completion is better (Microsoft C++ plugin never worked for me, both cquery and clangd are still incomplete).
Memory view during debugging.
Little things like showing the type of auto variable.

I don't disagree with that. I'm still getting used to VS so take my opinion with a grain of salt

These extensions (cpp extension, clangd, cquery) became much better in the past half-year, especially if you have compile_commands.json

Yes, and it also has slightly more features. Checkout the wiki page
I use it with emacs and it works damn well

Yeah, it is possible to configure it to not be as bad, but by default it has a ton of stuff going on in the GUI that is at best marginally useful. The top menu is also a bit confusing, with what basically feels like 3 separate application menus present at the same time. The fact that it pulls in whatever you have for the main toolbar in Kate into the main toolbar in a confusing way doesn't help either. It makes a great deal of sense to have a "New" button in kate, but that in no way means I want one in my IDE.

I have two setup. One with the arch package and another with their git master, both are crashing. You might have an older clang on your distro?

These young whippersnappers of today with their YouTube videos and what not.. Back in my day we just fired up vimtutor and learned our stuff hands on.

Well... You can download additional one (maybe even with the add-on downloader) or you can also roll your own, good thing there is a configuration editor in kate

You can edit/add configuration variables for CMake cache with a GUI

AppImage should mask the version installed on my system shouldn't it? The crash happened both on Ubuntu 18.04 and 12.04.
The bug report I submitted contains a minimal file that reproduces the issue: https://bugs.kde.org/show_bug.cgi?id=396310

Configuring a theme would take a long time to get everything looking good for me. How popular is KDeveloper compared to other IDEs? That would explain why there aren't they many good themes (at least for me) around.