[pjmlp]

Yes it is true, all major C compilers are now written in C++.

You can find everything related to GCC's C++ transition here:

https://gcc.gnu.org/wiki/gcc-in-cxx

On Windows even the C runtime, MSVCRT.dll got re-written in C++ and the C functions are actually extern "C" ones.

https://blogs.msdn.microsoft.com/vcblog/2014/06/10/the-great...

So a kind of small victory for us on the C++ side of the fence on the endless C vs C++ discussions.

Now the joke "my compiler compiles yours" has been reversed.

[i336_]

Wow, that's a surprise.

I'm really considering learning C++ now... I'm just hugely put off by the long compile times :( (I have 10+ year old hardware)

[pjmlp]

If you are on Windows, VS 2015 and the upcoming VS 2016 have lots of improvements regarding compile times.

https://blogs.msdn.microsoft.com/vcblog/2016/10/05/faster-c-...

https://blogs.msdn.microsoft.com/vcblog/2016/10/26/recommend...

https://channel9.msdn.com/Events/Connect/2016?sort=status&di...

Apple is also doing a similar work regarding incremental C and C++ builds, based on the work they did for Swift

https://www.youtube.com/watch?v=b_T-eCToX1I

C++ builds can be made bearable if you don't go crazy with template meta-programming, do forward declarations, only expose actually public data on the headers, instantiate most use templates.

But specially do use binary libraries, even across application modules. Don't spend endless time recompiling code that doesn't change.

[Matthias247]

> C++ builds can be made bearable if you don't go crazy with template meta-programming, do forward declarations, only expose actually public data on the headers, instantiate most use templates.

Exactly. E.g. QT based applications (which rely on object orientation, inheritance and virtual methods) compile reasonably fast. However the template oriented style (e.g. found in boost libraries) can increase compile times A LOT. I had more than factor 10 for one of my libraries that I ported from having boost as a dependency to QT. Although the template oriented style might really work faster at runtime, because there's less need for virtual function calls and other indirections.

[weavie]

I suspect with 10+ year old hardware he will not be on Windows.

[i336_]

You're right: Slackware :)

This ThinkPad T43 turned 10 this year :P

(In all fairness, my T60 is 9 years old now.)

[pjmlp]

I do have 10+ year old hardware on Windows, namely 7 and 10 versions of it.

IT only changes workstations when they break down or they cannot fulfill project requirements.

[echelon]

Before you invest time learning C++, have you considered Rust? There are pros and cons for and against each language, but as they're both operating in the same space it's something to keep in mind.

If you use C++ and believe Rust has the potential to reach the same marketshare / level of adoption C++ has now, then you should strongly consider learning Rust in the future. It has a compelling list of safety features and a more modern and ergonomic design.

I personally think Rust is going to go very far in the not too distant future, but I'm a slightly biased Rust fanboy. Do your own homework on the matter. You might decide your next language is Rust.

[i336_]

Well, the OP is a pro-Rust topic, so yeah.

As I said on the top-level comment that opened this thread, I'm tentatively considering Rust. I'd love for it to take off and become a serious and reliable contender. I have a tendency to be conservative and cautious (generally), so I'm seeing how things pan out.

[adrianN]

The compile times are not that long unless your program is very big. I also have 10 year old hardware.

[pg314]

I guess it depends on what you're used to. Each time I switch from C to C++, compile times take some adjusting.

If you're not careful about how you organise your C++ code (be careful what you put in headers, don't go crazy with templates), compiling can get really slow, even for relatively small projects.

Just #include <iostream> and the compiler needs to process 37,799(!) lines and more than a MB of data:

  echo '#include <iostream>' | g++ -E  -x c++ - | wc
     37799  104779 1280834

To contrast in C:

  echo '#include <stdio.h>' | gcc -E  -x c - | wc
       456    1638   20880

Comparing the compile times of PostgreSQL (C, minutes on an old laptop) and MySQL (C++, 30+ minutes) is also instructive.

Maybe when modules are finally introduced, things will improve.

[majewsky]

The numbers seem to depend heavily on your environment, by the way:

  $ uname -m
  x86_64
  $ source /etc/os-release && echo $NAME
  Arch Linux
  $ echo '#include <iostream>' | g++ -E  -x c++ - | wc
    27336   59448  643240

[pg314]

Sure. Mine was macOS Sierra.

If your <stdio> is comparable to mine, that's still about 30 times more bytes that the compiler sees for C++ compared to C.

[i336_]

I'd edit this into the original comment if I could; here seems to be a good spot to put it.

I think I should add a bit of context about what I mean by slow compile times: I feel comfortable if I can hit CTRL+S* and have my code rerun or restart within about half a second. At one second, it should either be executing or have output something and finished, and if it takes more than about 10 seconds to get to whatever point I'm prototyping or making a decision on, I get jittery.

It's partly because I have a ridiculously short feedback loop, but also because I am (for some reason) sensitive to interactivity latency and I prioritize responsiveness extremely highly. So long compile times tend to lean on those buttons and make me uncomfortable.

With this in mind, the only C++ experience I've had yet was doing some modifications to the Dillo web browser, which was the main web browser I was running on the 800MHz AMD Duron box I used between 2012-2014 (the same one I described in https://news.ycombinator.com/item?id=13344332).

It was a lot of fun - I modified the tab bar so tabs could be dragged around, moved between windows, etc :D - but the compile times were around 3 seconds! This was just for the test harness I built which had an absolute minimum of code in it; I was also using GCC precompiled headers for literally everything (my prototype code was a ~300 line .cpp file, no headers or anything). This was a really big adjustment for someone used to tcc (~10ms compile time) or gcc (~300ms compile time) who felt that gcc took juuuust a bit too long to do its thing.

I've seen C and C++ code compile on friends' i3 boxes (haven't seen what an i7 can do yet) and been amazed. I think when I have a machine like that I'll probably be able to seriously get into the language. (I actually have an i3 here but it had a memory failure several months ago, hopefully I can get some new DIMMs for it soon and see if the motherboard actually still works.)

--

* About ^S - I'm yet to play with Emacs which I understand has two keystrokes to save files; I mostly use Vim because it's installed everywhere. I far prefer ^S over ESC (Press)Shift ; (Release)Shift w Return i/a.

[pjmlp]

With the failure of Lisp Machines, Lucid pivoted into doing a Lisp like interactive environment for C++, with compilation at function/method level. There is an old VHS video that some uploaded to YouTube demoing it. Search for Lucid C++.

The last version of Visual C++ (v4) used a database repository as binary representation of C++ code, also offering an interactive experience.

The problem with both environments was that they required powerful hardware that most people weren't wiling to pay for and consequently died.

Microsoft is now having a smarter linker with db support for VSC++ 2017.

Both Apple and Google were discussing at last LLVM conference how to add similar capabilities, IDE friendly, to clang, partially based on the Swift Playgrounds development experience.

[i336_]

I think I vaguely recall learning about database-incorporating C++ compilers recently, and now I actually see them. This is really neat.

I'm definitely looking forward to LLVM getting these capabilities. It'll move C++ development forward by light years, I reckon. (For example, Chrome takes an hour to fully rebuild in CI on what I suspect is fairly modern server hardware.)

[pjmlp]

Here are the Lucid and IBM compilers I talked about.

Lucid Energize Demo VHS 1993

https://www.youtube.com/watch?v=pQQTScuApWk

IBM VisualAge C++ Professional 4.0

http://www.edm2.com/index.php/IBM_VAC_4.0

Sadly there isn't much information online, as this was on the days of BBS, Compuserve and other early online services.

[i336_]

Wow, that's really awesome.

If only the source code at https://archive.org/details/archiveteam-lucid-collection was complete :( that would be one source to getting a copy I could play with.

I'm definitely checking out VA C++ at some point though.

Thanks!

[AlphaSite]

Its all relative.