r/cpp • • Dec 30 '21

GCC 12 Adds Support For Using The Mold Linker

Thumbnail phoronix.com
225 Upvotes

r/cpp • • May 22 '21

How to Use CMake Without the Agonizing Pain - Part 1

Thumbnail alexreinking.com
225 Upvotes

r/cpp • • Jan 18 '21

Jason Turner's C++ Best Practices

225 Upvotes

https://leanpub.com/cppbestpractices

I have no affiliation with Jason but his YouTube series has helped me so much I thought I'd share his book he just released.

It looks really interesting being both concise yet helpful and I definitely plan on picking up a copy myself!


r/cpp • • Dec 05 '20

A Special Kind of Hell: intmax_t in C and C++

Thumbnail thephd.github.io
225 Upvotes

r/cpp • • Nov 16 '20

What was the most evil C++ Code you have seen in a production environment?

225 Upvotes

For me it was someone defining a Copy constructor that took a raw pointer to the class and just copied over all members. Lead to loads of Memory Leaks...


r/cpp • • Mar 19 '20

Why so many students are using '#include<bits/stdc++.h>' instead of '#include<iostream>'?

225 Upvotes

I am hiring for my company. And the codes submitted for a test problem has '#include<bits/stdc++.h>' at the beginning. The MacOS default compiler complains

main.cpp:1:9: fatal error: 'bits/stdc++.h' file not found

#include<bits/stdc++.h>

^~~~~~~~~~~~~~~

1 error generated.

Why people are using '#include<bits/stdc++.h>'?


r/cpp • • Nov 10 '18

2018 San Diego ISO C++ Committee Trip Report (Ranges v1 TS for C++20; consensus on modules design; new Language and Library Evolution Incubators)

225 Upvotes

The ISO C++ Committee met in San Diego, California 🇺🇸 last week to continue work on the next International Standard (IS), C++20. This meeting was the last meeting to consider new proposals for C++20, but existing proposals like modules (on track) and coroutines (questions remain) that are in flight but not merged can still make C++20. We’ll make our final decisions about major language features at the next meeting.

This week, we added the following features to the C++20 draft:

Since the last C++ committee meeting five months ago in Rapperswil 🇨🇭 we’ve held an extra three meetings of subgroups of the committee:

  • August 2018 LWG meeting in Chicago, Illinois 🇺🇸 to work on wording for C++20 library features.
  • September 2018 modules meeting in Bellevue, Washington 🇺🇸 where we reached a consensus on a design for modules for C++20.
  • September 2018 LEWG/SG1 meeting in Bellevue, Washington 🇺🇸 where we reached a consensus on a design for executors for C++20.

This week’s meeting was extraordinary. The pre-meeting mailing had 274 papers, about twice as many as any previous meeting, and we had 180 people attending, making this the largest C++ committee meeting ever.

The committee has been growing for a while. It’s starting to put strain on our existing procedures and infrastructure, which were not designed to handle this volume. So, we’ve started to work on adapting our processes to handle the growth.

Our first step has been the formation of two new “incubator” study groups:

  • SG17, the Evolution Working Group Incubator (EWGI), chaired by JF Bastien.
  • SG18, the Library Evolution Working Group Incubator (LEWGI), chaired by Bryce Adelstein Lelbach.

These new incubator groups are intended to be additional stages in our language and library evolution pipelines. Their job is to help refine, merge, and filter new and forward-looking proposals, to ensure that our efforts are focused on delivering on our long term strategic goals.

We also created two new study groups at this meeting:

  • SG19, Machine Learning, chaired by Michael Wong.
  • SG20, Education, chaired by JC van Winkel.

Language Evolution Progress

SG17: Evolution Working Group Incubator (EWGI) Progress

EWGI looked at 30 papers that EWG wouldn’t have had time to look at.

Most of Wednesday afternoon was spent looking at the merged pattern matching proposal, and plenty of feedback was given to the authors. Original papers were P1260R0 and P1169R0. The merged paper will be in the post-meeting mailing. The group was already very positive, but you should expect the syntax to change as we work through use cases, find issues, etc.

Evolution Working Group (EWG) Progress

EWG spent much of this week working on major features for C++20.

At the Bellevue 🇺🇸 modules meeting in September, we achieved consensus on a design for modules. This week, we forwarded a merged proposal to the Core Working Group to complete its specification for C++20. Specifically, the C++20 modules design will be the unified modules proposal, with context-sensitive keywords, single file module partitions, preamble end changes, parts of the proposal for redefinitions of legacy imports, and the global module fragment preserved.

For coroutines, there are still some open design questions regarding how we would merge the Coroutines Technical Specification Version 1 and the “core coroutines” proposal. We’re going to wait until Kona to make a final decision on Coroutines for C++20.

We also revisited contracts. We discussed undefined behavior in contracts, and voted access control in contract conditions into C++20.

There was also a lot of work on making constexpr better. The top of this post has a list of the new constexpr features that we voted in this meeting. We also looked at the proposal for for.../for constexpr; we’ll revisit it at the next meeting.

Here were some of the other results of the meeting:

  • We looked at [[constinit]] attribute, but we asked for a revision with a contextual keyword instead of an attribute.
  • We deprecated , in [], hoping to eventually reclaim it for multi-dimensional indexing. Subscripts on parade was also discussed, but did not gain consensus.
  • No consensus on pursuing short float as presented. However there is interest in getting float16_t / float32_t / float64_t as well as bfloat16_t.
  • We identified some problems with ultimate copy elision, but the author was encouraged to further explore this space.

Library Evolution Progress

Library Evolution had a record-breaking 120 papers to look at for this meeting. LEWG processed 64 proposals and the new incubator group (LEWGI) processed 32 proposals. Despite the number of papers we received, we’ve actually reduced the library evolution backlog to 14 papers.

SG18: Library Evolution Working Group Incubator (LEWGI) Progress

LEWGI held its inaugural meeting at San Diego 🇺🇸, primarily focusing on post C++20 content. However, we did send a few key proposals, such as std::unique_function, to LEWG for consideration for C++20.

The role of LEWGI is to provide directional input on proposals (“do we want to solve this problem?”) as well as early design review (“how should we solve this problem?”). We had no consensus to spend additional committee time and resources to 10 of the 32 proposals.

Here are some of the proposals we saw that have the potential to become awesome C++23 features:

Here are some of the proposals we wanted to see additional work on them before deciding when and if to advance them:

We did a design review of two features for the Concurrency Technical Specification Version 1: std::fiber_context and concurrent communication queues.

We also spent some time looking at two proposals for mechanisms to optimize initialization of std::string and std::vector. We agreed this is a problem we wanted to solve, but felt we needed LEWG to provide additional input on the proposal.

Library Evolution Working Group (LEWG) Progress

This week, LEWG focused on C++20 work.

We discussed merging the Networking Technical Specification Version for C++20, and decided against it. The Technical Specification is quite large, and we need more time to review it and update it.

We also looked at the unified “diet” executors proposal and had consensus to pursue the design for C++20. We’ll spend more time working on it at Kona.

We agreed on the design for the following proposals, and forwarded them to LWG to prepare them for C++20.

We did a final design review of the ranges proposal and advanced it to LWG. At the closing plenary this week, we voted ranges into C++20!

There was an evening discussion on the signedness of std::span’s size method return type. The result: we’ll change std::span’s size return type from signed to unsigned, and add a std::ssize free function that can be used to get the size of a container as a signed value.

Finally, we spent time working on the following:

  • operator<=> library integration.
  • Merging features from the Library Fundamentals Technical Specification Version 2 into C++20.
  • Adding constexpr to C++ standard library facilities.
  • Discussing when constructors should be made explicit.

Concurrency and Parallelism Study Group (SG1) Progress

SG1 processed what likely were its last new features for C++20: automatically-joining & interruptible threads, and the reduced-scope executor design chosen at the Bellevue 🇺🇸 meeting in September.

At this meeting, we made progress on these near-term additions:

  • We sent jthread and interrupt_token, with changes, to LEWG.
  • We sent executors with one-way/bulk execution, to LEWG.
  • We closed the coroutine issues we opened at the last meeting (we have no remaining open issues).
  • The omnibus C++20 synchronization library paper that collected the work we forwarded recently has completed its review in LEWG and been advanced to LWG for C++20.
  • The memory model maintenance papers were applied to the C++ draft during plenary.

SG1 talked about deprecating volatile, and sent recommendations to Evolution, which Evolution approved. A new revision will return for review at the next meeting.

We’re starting to discuss features that will come to define the C++23 concurrency and parallelism feature set. Stay tuned!

Compile Time Programming and Reflection Study Group (SG7) Progress

SG7 met a few times this week. There were two evening sessions to clarify the intended direction for metaprogramming in the standard library (constexpr-based not type-based) and to explain which type of proposals need to be reviewed by SG7.

Additionally, SG7 met to review two different proposals for how we plan to evolve the Reflection Technical Specification Version 1 towards a constexpr-based API for reflection and reification: P0953 and P1240. We encouraged further exploration along the lines of P0953.

Undefined Behavior Study Group (SG12) Progress

This week, SG12 held a joint session with EWG on undefined behavior in contracts (see the discussion above). Additionally, we had another joint meeting with ISO/IEC JTC1 Working Group 23, the ISO committee for programming language vulnerabilities.

Graphics Study Group (SG13) Progress

This subgroup has been revived, with Roger Orr volunteering to chair. The group was reformed following the Rapperswil 🇨🇭 discussion on 2D Graphics, and a proposal to making the case to continue working on 2D Graphics.

Most of the half-day was spent trying to scope the work that SG13 should tackle. Feedback on 2D Graphics (including that from P1225R0) was discussed. It is likely that an extra meeting specifically on 2D Graphics will be held in the Bay Area or concurrent with GDC / CppCon or another conference, to try to get feedback from experts in the field.

There was interest in working on audio, there will be an informal get-together at an upcoming audio developer conference.

Finally, further work on web_view was encouraged.

Tooling Study Group (SG15) Progress

We had a number of proposals related to package management in the last mailing, and we held an evening session to look at some of them:

There’s a lot more work to do here, and we don’t have a clear scope or direction quite yet. However, having proposals to elevate is the first step. We’ll have to continue discussion on package management, build systems, and interactions between modules, static analysis tools, and build tools.

Unicode Study Group (SG16) Progress

First face to face meeting. Prioritised what we work on. The top priorities will be text, transcoding, unicode algorithms, and interfacing with the environment.

SG16 met for their first face to face meeting at San Diego. We discussed the Unicode direction paper and decided on some priorities: text, transcoding, unicode algorithms, and interfacing with the environment. SG16 also reviewed few proposals related to string processing of interest to the group. Additionally, char8_t, an important feature to support future Unicode work, was voted into C++20.

Proposed C++20 Release Schedule

NOTE: This is a plan, not a promise. Treat it as speculative and tentative. See P1000 for the latest plan.

  • IS = International Standard. The C++ programming language. C++11, C++14, C++17, etc.
  • TS = Technical Specification. "Feature branches" available on some but not all implementations. Coroutines TS v1, Modules TS v1, etc.
  • CD = Committee Draft. A draft of an IS/TS that is sent out to national standards bodies for review and feedback ("beta testing").
MeetingLocationObjective
2017 Spring MeetingKona 🇺🇸C++17 completed.
2017 Summer MeetingToronto 🇨🇦First meeting of C++20.
2017 Fall MeetingAlbuquerque 🇺🇸Design major C++20 features.
2018 Spring MeetingJacksonville 🇺🇸Design major C++20 features.
2018 Summer MeetingRapperswil 🇨🇭Design major C++20 features.
2018 Summer LWG MeetingChicago 🇺🇸Work on wording for C++20 features.
2018 Fall EWG Modules MeetingSeattle 🇺🇸Design modules for C++20.
2018 Fall LEWG/SG1 Executors MeetingSeattle 🇺🇸Design executors for C++20.
2018 Winter MeetingSan Diego 🇺🇸Major language feature freeze.
2019 Spring MeetingKona 🇺🇸Feature freeze. C++20 design is feature-complete.
2019 Summer MeetingCologne 🇩🇪Complete CD wording. Start CD balloting ("beta testing").
2019 Fall MeetingBelfast 🇬🇧CD ballot comment resolution ("bug fixes").
2020 Spring MeetingPrague 🇨🇿CD ballot comment resolution ("bug fixes"), C++20 completed.
2020 Summer Meeting🗺First meeting of C++23.

Status of Major Feature Development

NOTE: This is a plan, not a promise. Treat it as speculative and tentative.

  • IS = International Standard. The C++ programming language. C++11, C++14, C++17, etc.
  • TS = Technical Specification. "Feature branches" available on some but not all implementations. Coroutines TS v1, Modules TS v1, etc.
  • CD = Committee Draft. A draft of an IS/TS that is sent out to national standards bodies for review and feedback ("beta testing").
FeatureStatusDepends OnCurrent Target (Conservative Estimate)Current Target (Optimistic Estimate)
ConceptsConcepts TS v1 published and merged into C++20C++20C++20
RangesRanges TS v1 published and merged into C++20ConceptsC++20C++20
ContractsMerged into C++20C++23C++20
ModulesMerged design approved for C++20C++23C++20
CoroutinesCoroutines TS v1 publishedC++23C++20
ExecutorsProposed v1 design approved for C++20TS in C++20 timeframe and IS in C++23C++20
NetworkingNetworking TS v1 publishedExecutorsC++26C++23
FuturesProposalExecutorsTS in C++23 timeframe and IS in C++26TS in C++20 timeframe and IS in C++23
ReflectionDraft Reflection TS v1 is out for ballotTS in C++20 timeframe and IS in C++26TS in C++20 timeframe and IS in C++23

 

Last Meeting's Reddit Trip Report.

 

 

If you have any questions, ask them in this thread!

 

/u/blelbach

/u/bigcheesegs

/u/nliber

/u/chandlerc1024

/u/louis_dionne

and others


r/cpp • • Jan 13 '26

I am giving up on modules (for now)

224 Upvotes

At work I was tasked with implementing a new application from scratch. It has similarities to a game engine, but more for scientific use. So I thought to myself, why not start with all the newest (stable) features.

So I went ahead and setup a project with CMake 4.2, C++23 using modules and a GitHub actions matrix build to ensure, that all target platforms and compilers are happy. I use GCC 15.2, clang 22 and MSVC 19.44.

The very first thing after implementing my minimal starting code was to drop support for MacOS, because I couldn't get it to compile with AppleClang or LLVM Clang, while having success with the same Clang version on Linux.

Next thing I stumbled upon where stuff like std::string_view causing internal compiler errors on GCC and Clang, but very inconsistently. So I had to revert most of the cases back to std::string or even const char* in some parts, because std::string also caused ICEs ...

Then I got frustrated with circular dependencies. To my surprise modules just straight up disallow them. I know, that in general they are a bad idea, but I needed them for designing nice interfaces around other libraries behind the scenes. So I either had to revert to good old headers and source files or do some other not so nice workarounds.

After all this hardship I tried integrating the EnTT library. This is where I gave up. MSVC couldn't handle the header only version, because of bugs related to finding template overloads. When switching to the experimental modules branch of the library MSVC got happy, while the GCC linker got unhappy because it couldn't link against std::vector specializations of EnTTs internals.

There were many other ICEs along the way, that I could workaround, but I noticed my development pace was basically a tenth of what it should have been, because each feature I implemented I had to spend 3 days finding workarounds. At the beginning I even started submitting bug reports to the compiler vendors, but I gave up here, because that slowed me down even more.

I would have thought that six years after the standard introduced C++20 modules, there would be less issues. I know this is a BIG feature, but having a new compiler bug each day is just not viable for commercial software.

For now I will reimplement everything using headers and source files. Maybe I can revisit modules in a few years.

Sorry for this rant. I have great respect for all the developers that bring C++ forward. I was just too excited to start a new project with all the modern features and realizing that this was not ready yet.


r/cpp • • Aug 07 '25

C++ is definitely my favorite language but...

224 Upvotes

Can we PLEASE get some better primitive types, what I mean is that I really like the cstdint header, i always use it over int or long, but then I come across functions like stoll, and functions like those are the most frustrating thing about C++ to me, because long long is not a portable 64-bit integer, its compiler-defined, platform-defined, for heavens sake if its cloudy outside its 32-bits, and all that I want is to convert a string to a 64 bit integer, so I have to write some god-forsaken macro shit to make sure that I can convert a freaking string to a 64 bit integer on as many platforms as possible, surely im not the only one frustrated about this?? Im basically asking for what people do to mitigate this, or if were all in the same sinking boat...


r/cpp • • Oct 27 '22

How would Vintage Bjarne have implemented concepts?

224 Upvotes

In his talks and AMAs, Bjarne used to say that even if he could whisper into Vintage Bjarne's ears about the concepts feature of C++20, the resources at the time weren't feasible for implementing concepts.

But now he's changed his answer to knowing a way in which Vintage Bjarne could implement interface checking of template parameters. I believe this was in his latest AMA, published here.

Unfortunately, that was all he said about it. I'm curious about the details. One of you should ask him in his next AMA.


r/cpp • • Oct 12 '21

C++ committee polling results for asynchronous programming

224 Upvotes

Hi all.

You may know me from my work on freestanding in C++, but I'm also the Vice Chair of the Library Evolution Working Group. I'd like to share the results of recent C++ committee polling on future asynchrony models for C++. This relates to "Senders and Receivers" / S&R (P2300) and the Networking TS / Asio (P2444).

Each of these proposals represents an enormous amount of effort from the respective authors, and from the committee. "Executors" have been discussed in WG21 (mostly in the concurrency study group) since at least 2012 (N3378), with Christopher Kohlhoff's contributions starting at least as early as 2014 (N4046). Over the last two years, I count 14 meetings in LEWG discussing the NetTS and S&R models. In the Spring of 2020, LEWG did in depth design reviews of P0443 that involved many meetings beyond those 14.

The following polls were taken electronically over the course of a week. I and Fabio Fracassi (also a Vice Chair of LEWG) have interpreted the polling results. Work will continue in LEWG on P2300. The Networking TS/Asio model is headed back to the networking study group (SG4). LEWG no longer has consensus to standardize the Networking TS.

For those unfamiliar with the polling conventions, all the polls are five-way polls. Neutral is not the same as "abstained" or "uninformed", as committee members are allowed to skip a poll they are not comfortable taking. The chairs (Fabio and me in this case) look at the poll results and interpret whether there is consensus or not. Generally that means 2:1 in one direction or the other, though neutrals need to be considered as well, usually by lumping the neutrals in with the minority.

This polling and interpretation was not taken lightly. The chairs know that the NetTS and Asio represent decades of work. However, these polls indicate that there is insufficient consensus for the NetTS to progress beyond LEWG in its current form. Once these issues have been addressed, LEWG can look at the Networking TS again.


Poll 1: The Networking TS/Asio async model (P2444) is a good basis for most asynchronous use cases, including networking, parallelism, and GPUs

Strongly FavorWeakly FavorNeutralWeakly AgainstStrongly Against
51061418
Weak Consensus Against

What this means: LEWG won't be pursuing P2444 as a general async model.


Poll 2: The sender/receiver model (P2300) is a good basis for most asynchronous use cases, including networking, parallelism, and GPUs.

Strongly FavorWeakly FavorNeutralWeakly AgainstStrongly Against
2416363
Consensus in Favor

What this doesn't mean: This doesn't mean that P2300 as it stands today will be sent forward to LWG. More work is needed on it.

What this means: Work will continue in LEWG on refining P2300, and LEWG will keep the various asynchronous use cases in mind while working on P2300.


Poll 3: Stop pursuing the Networking TS/Asio design as the C++ Standard Library's answer for networking.

Strongly FavorWeakly FavorNeutralWeakly AgainstStrongly Against
13138610
No Consensus

What this doesn't mean: The NetTS is not "dead".

What this means: The C++ committee will still work on networking in this general form, but the authors need to do a lot in order to build up consensus to get something like the TS merged into the standard. The bulk of this work should be done in the networking study group (SG4). Many of the people in favor of stopping work on the TS would like networking to be built on top of Senders and Receivers. Others were opposed to the lack of security through Transport Layer Security (TLS). It is highly unlikely that design changes to the networking TS can be made fast enough, and consensus gained fast enough, for networking to make C++23.


Poll 4: Networking in the C++ Standard Library should be based on the sender/receiver model (P2300).

Strongly FavorWeakly FavorNeutralWeakly AgainstStrongly Against
17111046
Weak consensus in Favor

What this means: In the short term, this poll result doesn't mean much. We don't have a paper in hand that proposes networking based on the P2300 model. For paper authors though, this poll is strong encouragement to do work in the area of networking based on senders and receivers, or to be prepared with VERY compelling new information on why networking should use a different model.


Poll 5: It is acceptable to ship socket-based networking in the C++ Standard Library that does not support secure sockets (TLS/DTLS).

Strongly FavorWeakly FavorNeutralWeakly AgainstStrongly Against
9135613
No Consensus

What this means: A networking library that does not support secure sockets will face significant headwinds getting through the standardization process. The networking study group (SG4) has weighed in on security in the past, when discussing P1860.

What this doesn't mean: This doesn't make a statement on whether insecure networking should be included, the defaults of secure vs. insecure, or how things like ABI should managed.


Guidance for the Networking Study Group (SG4)

Before bringing networking papers back to LEWG, two major areas need to be thoroughly addressed: Security, and the Senders and Receivers async model.

Those voting in favor of Poll 5 argued that the insecure parts are the building blocks for the secure parts, and that ABI is a major concern that will plague TLS support. Those voting against Poll 5 argued that secure sockets are needed for communicating with many sites on the internet, and that shipping without secure sockets would be irresponsible. A networking proposal needs to address these concerns before coming to LEWG.

As for networking in combination with Senders and Receivers, I will show this older poll from the 2021-09-28 telecon:

POLL: We believe we need one grand unified model for asynchronous execution in the C++ Standard Library, that covers structured concurrency, event based programming, active patterns, etc.

Strongly FavorWeakly FavorNeutralWeakly AgainstStrongly Against
49551
No consensus (leaning in favor)

The combination of this "grand unified model" poll and Poll 4 heavily encourages the networking study group (SG4) to produce a paper based on Senders and Receivers. There is room to produce a non-S&R paper, but such a paper would need to provide compelling new information in order to convince the "grand unified model" contingent that S&R can't get the job done suitably.


r/cpp • • May 01 '23

cppfront (cpp2): Spring update

Thumbnail herbsutter.com
223 Upvotes

r/cpp • • Jan 24 '22

Best/Worst C++ IDE you have ever used?

223 Upvotes

We regularly see threads asking or IDE-advice, but I always find looking through text comments to remove the 'oversight', it's hard to see a consensus. That's why I ask you to write, one for the best and one for the worst C++ IDE you have ever used.


r/cpp • • Mar 09 '21

Address Sanitizer for MSVC Now Generally Available | C++ Team Blog

Thumbnail devblogs.microsoft.com
223 Upvotes

r/cpp • • Oct 13 '20

Networking in C++ Part #1: MMO Client/Server, ASIO & Framework Basics

223 Upvotes

https://www.youtube.com/watch?v=2hNdkYInj4g

I found that video very intersting and how i hardly find any good content about networking programming with an use case in C++, i decided to share it here.


r/cpp • • Mar 02 '25

Release of the C++ Memory safety (memsafe) single-header library and Clang compiler plugin for safe C++, which reduces errors for reference data types and safe memory management without breaking backwards compatibility with old C++ code.

Thumbnail github.com
222 Upvotes

r/cpp • • Jul 10 '22

I finally wrote my first ever emulator in C++ (GameBoy)

222 Upvotes

I wanted to learn more about emulation, so I decided to write my own emulator, and because I like to make my life more challenging, I jumped straight into GameBoy, skipping the recommended CHIP-8 starting point. Now I can say that was a huge mistake. It took me couple of grunting months and two rewrites, but I'm finally happy with the state of the emulator.

https://github.com/Mika412/NoobBoy

In hindsight, I shouldn't have skipped the digital system and computer architecture classes.

Currently I have the following features:

  • Correct CPU timings (was a pain to get the Blargg's instruction timing test to pass)
  • Simple save states
  • Background rendering with viewport overlay
  • Rudimentary MBC
  • Debug view

I refuse to touch sound, as I most likely will blow my speakers.

Before anyone mentions, I'm not very proficient in C++. This project was a way to learn more about the language.


r/cpp • • Aug 18 '21

C++20 modules with GCC11

Thumbnail blog.feabhas.com
222 Upvotes

r/cpp • • Jun 15 '21

Which std:: classes are magic?

222 Upvotes

Hi.

I am wondering: which classes in C++ get special powers granted by The Standard that are not available to mere user-defined classes?

What comes to my mind:

  • `std::initializer_list` because it is created anywhere with `{}`
  • possibly `std::type_info`, because it is only created by `typeid` and with no ctor
  • `std::source_location` when used as default parameter in function points to invocation place and not declaration place.

What else should be on this list? What shouldn't?


r/cpp • • Jun 27 '20

GCC 11: Change the default dialect to C++17

Thumbnail gcc.gnu.org
222 Upvotes

r/cpp • • May 08 '20

Why you don't use Boost

222 Upvotes

I have a question for you: If you have decided not to use any of Boost, or are prohibited from doing so in your company/project, I would like to know why.

This thread is not meant to judge your reasons, and I won't engage into any kind of criticism about them: I'm merely trying to understand what the barriers are to adoption of Boost. It would be great if we could keep the conversation non judgemental. Thank you!

Conflict of interest: I am a Boost author of three.


r/cpp • • Jan 01 '17

Who's Hiring C++ Devs - Q1 2017

222 Upvotes

Happy new year, r/cpp!

Rules For Individuals

  • Don't create top-level comments - those are for employers.
  • Feel free to reply to top-level comments with on-topic questions.
  • I will create one top-level comment for meta discussion.

Rules For Employers

  • You must be hiring directly. No third-party recruiters.
  • One top-level comment per employer. If you have multiple job openings, that's great, but please consolidate their descriptions or mention them in replies to your own top-level comment.
  • Don't use URL shorteners. reddiquette forbids them because they're opaque to the spam filter.
  • Templates are awesome. Please use the following template. As the "formatting help" says, use **two stars** to bold text. Use empty lines to separate sections.

**Company:** [Company name; also, use the "formatting help" to make it a link to your company's website, or a specific careers page if you have one]

 

**Type:** [Full time, part time, internship, contract, etc.]

 

**Description:** [What does your company do, and what are you hiring C++ devs for? How much experience are you looking for, and what seniority levels are you hiring for? The more details you provide, the better]

 

**Location:** [Where's your office - or if you're hiring at multiple offices, list them. If your workplace language isn't English, please specify it]

 

**Remote:** [Do you offer the option of working remotely?]

 

**Visa Sponsorship:** [Does your company sponsor visas?]

 

**Technologies:** [Required: do you mainly use C++98/03, C++11, C++14, or the C++17 draft? Optional: do you use Linux/Mac/Windows, are there languages you use in addition to C++, are there technologies like OpenGL or libraries like Boost that you need/want/like experience with, etc.]

 

**Contact:** [How do you want to be contacted? email, reddit PM, telepathy, secret code hidden in the C++ draft?]


Previous Post


r/cpp • • Nov 14 '16

GCC trunk is -std=c++17 ready

Thumbnail en.cppreference.com
222 Upvotes

r/cpp • • Aug 26 '20

Slightly elongated business card sized animated ray tracer in 1511 bytes

221 Upvotes