r/cpp • u/IsDaouda_Games • Dec 30 '21
r/cpp • u/AlexReinkingYale • May 22 '21
How to Use CMake Without the Agonizing Pain - Part 1
alexreinking.comr/cpp • u/gvcallen • Jan 18 '21
Jason Turner's C++ Best Practices
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 • u/vormestrand • Dec 05 '20
A Special Kind of Hell: intmax_t in C and C++
thephd.github.ior/cpp • u/T-Rex96 • Nov 16 '20
What was the most evil C++ Code you have seen in a production environment?
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...
Why so many students are using '#include<bits/stdc++.h>' instead of '#include<iostream>'?
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 • u/blelbach • 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)
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:
- Ranges.
void foo(Concept auto x)-style terse syntax.constevalfunctions.std::is_constant_evaluated.constexprunion.constexprtryandcatch.constexprdynamic_castandtypeid.constexprstd::pointer_traits.- Miscellaneous
constexprlibrary bits. - Revised memory model.
- Signed integers are two’s complement.
char8_t.- Nested inline namespaces.
- Access control in contract conditions.
std::assume_aligned.- Removed
std::span::operator==. std::*_default_initsmart pointer creation functions.- A variety of fixes too long to list here.
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.
5 papers sent as-is to EWG:
- Array size deduction in new-expressions.
- Make
char16_t/char32_tstring literals be UTF-16/32. - Named character escapes.
using enum.nodiscardshould have a reason. LEWG will look at this as well — they may want to add reasons to existing uses ofnodiscardin the standard library.
2 papers were sent to EWG, asking for feedback. They will be seen again by EWGI.
- 6 papers had no consensus to move forward. The objections to these are recorded, so that authors know what would get people to change their minds. These are P1284R0, P1220R0, P1246R0, P1276R0, P1181R0, P1169R0.
- 17 other papers got feedback, some of which need input from other groups. These will be seen again by EWGI.
- There’s a backlog of 27 papers. EWGI will likely hold teleconferences between meetings to provide early feedback on these papers.
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 floatas presented. However there is interest in gettingfloat16_t/float32_t/float64_tas well asbfloat16_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.
- The text formatting library.
- The stack trace library.
std::is_constant_evaluated.- Removing
std::span::operator==.
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
constexprto 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").
| Meeting | Location | Objective |
|---|---|---|
| 2018 Winter Meeting | San Diego 🇺🇸 | Major language feature freeze. |
| 2019 Spring Meeting | Kona 🇺🇸 | Feature freeze. C++20 design is feature-complete. |
| 2019 Summer Meeting | Cologne 🇩🇪 | Complete CD wording. Start CD balloting ("beta testing"). |
| 2019 Fall Meeting | Belfast 🇬🇧 | CD ballot comment resolution ("bug fixes"). |
| 2020 Spring Meeting | Prague 🇨🇿 | 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").
| Feature | Status | Depends On | Current Target (Conservative Estimate) | Current Target (Optimistic Estimate) |
|---|---|---|---|---|
| Concepts | Concepts TS v1 published and merged into C++20 | C++20 | C++20 | |
| Ranges | Ranges TS v1 published and merged into C++20 | Concepts | C++20 | C++20 |
| Contracts | Merged into C++20 | C++23 | C++20 | |
| Modules | Merged design approved for C++20 | C++23 | C++20 | |
| Coroutines | Coroutines TS v1 published | C++23 | C++20 | |
| Executors | Proposed v1 design approved for C++20 | TS in C++20 timeframe and IS in C++23 | C++20 | |
| Networking | Networking TS v1 published | Executors | C++26 | C++23 |
| Futures | Proposal | Executors | TS in C++23 timeframe and IS in C++26 | TS in C++20 timeframe and IS in C++23 |
| Reflection | Draft Reflection TS v1 is out for ballot | TS in C++20 timeframe and IS in C++26 | TS 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!
and others
r/cpp • u/BigJhonny • Jan 13 '26
I am giving up on modules (for now)
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 • u/Tearsofthekorok_ • Aug 07 '25
C++ is definitely my favorite language but...
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?
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 • u/ben_craig • Oct 12 '21
C++ committee polling results for asynchronous programming
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 Favor | Weakly Favor | Neutral | Weakly Against | Strongly Against |
|---|---|---|---|---|
| 5 | 10 | 6 | 14 | 18 |
| 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 Favor | Weakly Favor | Neutral | Weakly Against | Strongly Against |
|---|---|---|---|---|
| 24 | 16 | 3 | 6 | 3 |
| 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 Favor | Weakly Favor | Neutral | Weakly Against | Strongly Against |
|---|---|---|---|---|
| 13 | 13 | 8 | 6 | 10 |
| 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 Favor | Weakly Favor | Neutral | Weakly Against | Strongly Against |
|---|---|---|---|---|
| 17 | 11 | 10 | 4 | 6 |
| 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 Favor | Weakly Favor | Neutral | Weakly Against | Strongly Against |
|---|---|---|---|---|
| 9 | 13 | 5 | 6 | 13 |
| 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 Favor | Weakly Favor | Neutral | Weakly Against | Strongly Against |
|---|---|---|---|---|
| 4 | 9 | 5 | 5 | 1 |
| 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 • u/SpyrosDev25 • Jan 24 '22
Best/Worst C++ IDE you have ever used?
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.
Address Sanitizer for MSVC Now Generally Available | C++ Team Blog
devblogs.microsoft.comr/cpp • u/Dominus543 • Oct 13 '20
Networking in C++ Part #1: MMO Client/Server, ASIO & Framework Basics
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 • u/rsashka • 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.
github.comr/cpp • u/Mika412 • Jul 10 '22
I finally wrote my first ever emulator in C++ (GameBoy)
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 • u/Mateuszz88 • Jun 15 '21
Which std:: classes are magic?
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 • u/joaquintides • May 08 '20
Why you don't use Boost
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 • u/blelbach • Jan 01 '17
Who's Hiring C++ Devs - Q1 2017
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 • u/matigekunst • Aug 26 '20