-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
Dot product on misaligned data
https://lemire.me/blog/2025/07/14/dot-product-on-misaligned-data/
https://redd.it/1m0clws
@r_cpp
There is a std::chrono::high_resolution_clock, but no low_resolution_clock
https://devblogs.microsoft.com/oldnewthing/20250714-00/?p=111375
https://redd.it/1m099la
@r_cpp
Preparing for C++/C# roles at trading firms what should I focus on over the next 2 years?
Hi everyone,
I’m a recent CS graduate who just started a job working with C# and C++. My long-term goal is to work at a trading firm on a C++/C# development team.
I’m aiming to apply in about 2 years, once I’ve built up enough experience and skills to be a competitive candidate. I’d really appreciate any guidance on:
1. What skills/knowledge should I focus on over the next 2 years to prepare for interviews at trading firms?
• Systems programming? Leetcode-style DSA? Networking? Multithreading?
• Are there specific books, projects, or open-source contributions that help?
2. Do trading firms hire people with just 2 years of experience, or do they mainly target new grads and senior/experienced hires?
3. What is the interview process like for someone with 1–3 years of experience?
• Is it mostly Leetcode questions, or more focused on systems design, low-latency coding, etc.?
https://redd.it/1m041dh
@r_cpp
The Best C++ Library
https://mcyoung.xyz/2025/07/14/best/
https://redd.it/1lzyeyc
@r_cpp
Spicy: Generating Robust Parsers for Protocols & File Formats
https://docs.zeek.org/projects/spicy/en/latest/index.html
https://redd.it/1lzxme7
@r_cpp
New C++ Conference Videos Released This Month - July 2025 (Updated to Include Videos Released 2025-07-07 - 2025-07-13)
**C++Online**
2025-07-07 - 2025-07-13
* Command Line C++ Development - Mathew Benson - [https://youtu.be/a9C0KgQcLYU](https://youtu.be/a9C0KgQcLYU)
* A constexpr Virtual CRTP Comparison - Amir Kirsh - [https://youtu.be/QywrIVM1bos](https://youtu.be/QywrIVM1bos)
* C++ Type Traits Without Compiler Intrinsics - The Promise of Static Reflection in C++ - [https://youtu.be/EK74rV1M7uc](https://youtu.be/EK74rV1M7uc)
2025-06-30 - 2025-07-06
* Essential C++ Tips and Tricks for the Ultimate Cpp Performance - Andreas Fertig - [https://youtu.be/\_lwuqH72ycM](https://youtu.be/_lwuqH72ycM)
* Keynote: How To Improve Software Innovation Through Diversity - Sejal Gupta - [https://youtu.be/ym8mt\_LGWew](https://youtu.be/ym8mt_LGWew)
* How to Write a Base Level Cpp Library for Safety Critical Software in C++ - Anthony Williams - [https://youtu.be/NWTowFQ1c0I](https://youtu.be/NWTowFQ1c0I)
**ACCU Conference**
2025-07-07 - 2025-07-13
* The CUDA C++ Developer Toolbox - Bryce Adelstein Lelbach - [https://youtu.be/tDegOeivJs4](https://youtu.be/tDegOeivJs4)
* Mental Health in Software Development - Tanzt kaputt, was euch kaputt macht! - Dom Davis - [https://youtu.be/gbs-qMIlYUg](https://youtu.be/gbs-qMIlYUg)
* Heaps Don’t Lie - Guidelines for Memory Allocation in C++ - Mathieu Ropert - [https://youtu.be/74WOvgGsyxs](https://youtu.be/74WOvgGsyxs)
2025-06-30 - 2025-07-06
* The Next Coding Horizon - Proactive LLMs for Enhanced Productivity - Anastasia Kazakova - [https://youtu.be/ak7Q6TEOJnQ](https://youtu.be/ak7Q6TEOJnQ)
* The C++ Execution Model - Bryce Adelstein Lelbach - [https://youtu.be/6zq5ZmCvldU](https://youtu.be/6zq5ZmCvldU)
**ADC**
2025-07-07 - 2025-07-13
* A Spatial Audio Primer - Emma Fitzmaurice - [https://youtu.be/FOBPHBdi2gE](https://youtu.be/FOBPHBdi2gE)
* Auralization and Active Sound Design with Spatial Audio on a Vehicle Simulator - Joshua Chaiphas - [https://youtu.be/ZjAyrx6JVbc](https://youtu.be/ZjAyrx6JVbc)
* Guide to C++ ValueTrees - The Secret Weapon of JUCE - Brett g Porter - [https://youtu.be/usUz6CHl-Es](https://youtu.be/usUz6CHl-Es)
2025-06-30 - 2025-07-06
* Branch-Free Oscillators for Virtual Analog Software Synthesizer Applications in C++ - Angus Hewlett - [https://youtu.be/5Les61Hh46w](https://youtu.be/5Les61Hh46w)
* Spatial Localization and Techniques for Synthesizing Real-Time Binaural Audio for Headphones - Harsha Vardhan Rapeti - [https://youtu.be/A1XHIy1GgNQ](https://youtu.be/A1XHIy1GgNQ)
* Debugging Audio Content With Visuals - A Debugger Extension and Some Other Helpful Tools - Maxime Coutant - [https://youtu.be/tZMA49ZnMbQ](https://youtu.be/tZMA49ZnMbQ)
https://redd.it/1lzqie7
@r_cpp
Suggest some code editors for C++ in android
https://redd.it/1lzjkeg
@r_cpp
This-pointing Classes
https://biowpn.github.io/bioweapon/2025/07/13/this-pointing-classes.html
https://redd.it/1lzdfu8
@r_cpp
Hungarian Notation, for us who use it
**Note:** *Most developers aren't fans of Hungarian Notation, and that's totally fine. This thread is for those of us who do use it, and how to make it effective. Let's discuss this niche area; we know we're a small minority*
# Hungarian Notation
**How do you use this style to maximize your effectiveness? Do you have any tips?**
To start I can inform the most important areas for me using Hungarian.
For me, Hungarian Notation is a technique to maximize the speed of visually processing and understanding code. Three main areas for speed
### Filtering out unimportant code
I rarely "read" code, I **scan** it. My eyes typically focus on columns 5-40 in the editor. I also always have a thin line above each method in `*.c, *.cpp` files. This line marks where a method begins. This pattern speeds up scrolling through code. My scroll step is set to 10 lines, so the slightest tick on scroll wheel moves me 10 lines up or down. I also use a Logitech mouse with a free-spinning scroll wheel, allowing me to scroll about 500 lines with a single finger movement. The line above each method helps my eye catch the method name when scrolling fast through the code.
example:
```c
/** ---------------------------------------------------------------------------
* @brief describe method
* ...
*/
void names::reserve(size_t uSize)
{
}
```
When scanning code, my eye only sees the prefixes, and that's where Hungarian Notation helps me filter out less important elements. Prefixes for primitive types show me what I can skip over.
### Minimizing abbreviations and ensuring code consistency
The only abbreviations allowed are those in a predefined list for the project. All these abbreviations must be self-explanatory to the team. They should essentially understand what the abbreviation means without any explanation. Example: an integer variable might be `iSomeName`. All programmers on the team can understand each other's code, and it's easy to read the code even outside of editors.
Hungarian Notation helps prevent cryptic names (often abbreviations) and ensures variables have better names. Awkward code often looks "ugly" when Hungarian Notation is practiced, making bad code more apparent. Hungarian Notation itself isn't particularly "pretty." Thats makes bad code even more uggly.
For me, the most important task isn't to show the type (though that helps), but rather to quickly find **important code**. Often, important code is only a fraction of other code (under 10%).
### Using suffixes to indicate reach
I end global methods or variables with `_g`, instead of starting with `gSomeName` as many do. This is a less critical marker, more about understanding the consequences of changing a value and comprehending the code as a whole, which is why this type of marking is at the end (its not something that improves speed). Debug and static variables have their own markers, becoming `*_d` for debug and `*_s` for static. I always add an underscore "\_".
### AI and Hungarian Notation
When I look at unfamiliar code, perhaps something interesting on GitHub or elsewhere online, I usually ask an AI to rewrite the code and I pre train AI with the style. I have a template with Hungarian Notation as the coding style, and once the AI rewrites it, I can read the code without much trouble. This makes even large amounts of code quickly "readable."
I also find that AI works much better with Hungarian Notation. The AI manages to name things more effectively, and I don't have to rewrite too much.
### Mental Stress
This is not for speed but more to make programming fun.
For me, this might be the most significant effect. Hungarian Notation means I can almost always understand code, regardless of who wrote it. It remains readable without needing to try to remember thing and I can focus on what the code actually does and how it works. The need to figure out what variables are almost completely disappears, which is perhaps the worst part of other coding styles. This means I don't have to waste energy memorizing the code, making
Using &vector::at(0) instead of vector.data()
I have vector access like this:memcpy(payload.data() + resolved, buf.data(), len);
I'd like bounds checks in release mode and thought about rewriting it into:memcpy(&payload.at(resolved), &buf.at(0), len); // len > 0 is assumed
But I don't think it's idiomatic and defeats the purpose of the .data() function. Any thoughts?
https://redd.it/1lymbig
@r_cpp
Generate trello/kanban boards from source code for project management
Currently working on a [Trello/Kanban-like](https://en.wikipedia.org/wiki/Comparison_of_scrum_software) tool to manage planning and remember programming tasks.
What differentiates it from conventional systems is that task information is stored directly within the code itself, rather than in a separate database.
Personally, I've always felt it was suboptimal to store information and other code-related details outside of the codebase. And very anoying that you cant link into the code.
Why put this in "cpp", I am C++ developer and this is the focus for this tool,
---
*The Tool: An Advanced Search application*
To get to the core of my **question**: the tool is essentially an **advanced search engine** that can find and collect information from source code. I've progressed to the point where it can search for multiple values, not just a single string.
For example, it can search for `#task #database`, and if both of these values are present on a single line, it registers as a hit. Combining words in this way allows for quite sophisticated code discovery.
However, **extracting** information from the code without cluttering it too much isn't as straightforward.
My idea is to implement a **flexible key-value logic** that's easy to adapt.
Here are some examples of how it could look:
* `// [type: task] [user:per] [tag: database, sqlserver] [description: information about the task] [status=todo]`
* `// type=task tag=database tag=user description="information about the task"`
* `// {type:task,priority:high,tag:database,tag:user,description:"information about the task", status=done}`
The above formats is not that difficult to create queries for to scan code after and match and extract information from to create an overview board. Same query will match all formats.
- Does this clutter code to much or cause to much unrelated code modifications in repository? If the task is close to whats going to be worked on in the code my guess is that its not that problematic
- What type of information do developers need for these task? Normally these descriptions in kanban tools are short, sometimes you want a history but that is solvable within the code
- Are there better formats to describe and is the key-value bad, is there maybre a better format. Key-value is something most developers are used to so thats the reason now
Link to the tool on github: https://github.com/perghosh/Data-oriented-design/releases/tag/cleaner.1.0.0
https://redd.it/1ly3oz3
@r_cpp
C++, Autonomous Driving and future work opportunities
Hello guys.
I start by saying I'm new to this forum, I'm young and I will ask dumb questions in this post.
Would you say that learning C++ to work in robots/autonomous driving project, will help me, in the future, to land jobs at even big tech companies?
All I hear talk about is JS and Python.
Although I think it'll be much easier to learn those languages after having worked on the previously stated project, I'm still scared that I'll waste my time running after non-profitable projects (yes I care about money a lot unfortunately and I connect a good 30% of my worth with how much money I make)
Thank you guys.
https://redd.it/1ly1kel
@r_cpp
Is eclipse really that bad?
I've heard people say eclipse ide is bulky or unintuitive, but i dont like vs code and im on linux so cant use vs, is eclipse bad enough that i should look for something else or is it the best option for a complete ide for my situation?
https://redd.it/1lxzg5s
@r_cpp
Cpp for anything other than embedded
Hello guys.
Iam professionaly using cpp for embedded for over 5 years now. I have never in my life built anything in cpp which is not embedded. I always run my code on an mcu. wifi, uart and other hardware stuff. I have written pure cpp modules which does not require hw too. I have never used exceptions or any compute intensive features of cpp.
Now iam planning to investigate other aspects of cpp outside of embedded.
Iam using vscode for writing my code.
- Can i build GUIS with cpp for windows for example? If yes, with what software? ( visual studio, qt? )
- Can I build a web server which hosts react apps? ( spa possibly )
If you could recommend libraries, frameworks and an IDE to build i would really appreciate it and any advice to start and any gotchas!
Thank you.
https://redd.it/1lxv9jn
@r_cpp
Code Review Request: MMO Client/Server architecture
https://github.com/silvematt/NECRO-MMO
https://redd.it/1lxn8gt
@r_cpp
I scraped 100k C++ jobs directly from corporate websites
I realized many roles are only posted on internal career pages and never appear on classic job boards.
So I built an AI script that scrapes listings from 70k+ corporate websites.
Then I wrote an ML matching script that filters only the jobs most aligned with your CV, and yes, it actually works.
You can try it here (for free).
(If you’re still skeptical but curious to test it, you can just upload a CV with fake personal information, those fields aren’t used in the matching anyway.)
https://redd.it/1m0d43z
@r_cpp
asio-awaitable-future: Convert std::future to asio::awaitable seamlessly
# 🚀 asio-awaitable-future: Bridge std::future and asio coroutines
Hey r/cpp! I've been working on a header-only C++20 library that solves a common problem when working with asio coroutines.
# The Problem
When using asio coroutines, you often need to integrate with existing async code that returns `std::future<T>`. Direct usage blocks the IO thread, which defeats the purpose of async programming.
# The Solution
My library provides a simple `make_awaitable()` function that converts any `std::future<T>` to `asio::awaitable<T>` without blocking:
// Before: This blocks the IO thread
auto result = future.get();
// After: This doesn't block
auto result = co_await asio_future::make_awaitable(std::move(future));
# Key Features
✅ Header-only (easy integration)
✅ Non-blocking (uses thread pool)
✅ Exception-safe
✅ C++20 coroutines + asio
✅ MIT licensed
# Example Use Cases
* Blocking tasks
* Error handling in future
* CPU-intensive tasks
**GitHub:** [https://github.com/xialeistudio/asio-awaitable-future](https://github.com/xialeistudio/asio-awaitable-future)
Would love to hear your thoughts and feedback! 🙏
# Questions for the community:
1. Have you encountered similar challenges with asio integration?
2. Any suggestions for additional features?
3. Performance optimization ideas?
https://redd.it/1m064y1
@r_cpp
`generator`'s `Allocator` template parameter is redundant
While implementing a generator type with a slightly different interface (https://github.com/jhcarl0814/ext\_generator ), I found that the `Allocator` template parameter is only used during construction and not used when the generator is traversed, dereferenced or destroyed. (So maybe it's OK to have `Allocator` present only during construction (e.g. in parameter list) but absent after that?) Then I tried to remove the `Allocator` template parameter from the type and the generator still supports custom allocators. (Callers can still "provide no arguments" when callees want to use custom **default-constructible** allocators.)
Examples without custom allocator:
ext::generator_t<std::string> f() { co_yield std::string(); }
auto c = f();
ext::generator_t<std::string> l = []() -> ext::generator_t<std::string> { co_yield std::string(); }();
Examples with custom allocator:
ext::generator_t<std::string> f(std::allocator_arg_t, auto &&) { co_yield std::string(); }
auto c = f(std::allocator_arg, allocator);
ext::generator_t<std::string> l = [](std::allocator_arg_t, auto &&) -> ext::generator_t<std::string> { co_yield std::string(); }(std::allocator_arg, allocator);
Examples with custom default-constructible allocator:
ext::generator_t<std::string> f(std::allocator_arg_t = std::allocator_arg_t{}, std::allocator<void> = {}) { co_yield std::string(); }
auto c = f();
ext::generator_t<std::string> l = [](std::allocator_arg_t = std::allocator_arg_t{}, std::allocator<void> = {}) -> ext::generator_t<std::string> { co_yield std::string(); }();
Does anyone here know the rationale behind that template parameter, like what can not be achieved if without it?
I also noticed that "std::generator: Synchronous Coroutine Generator for Ranges" (https://wg21.link/p2502 ) talks about type erasing the allocator and some `std::generator` implementations store function pointers invoking allocator's member functions saying they're doing type erasing. But my implementation does not use any function pointers taking `void*` and still can call the right allocator, because coroutines are already manipulated by type erased handles??? Is there something wrong with my implementation?
https://redd.it/1m02j38
@r_cpp
-Wexperimental-lifetime-safety: Experimental C++ Lifetime Safety Analysis
https://github.com/llvm/llvm-project/commit/3076794e924f
https://redd.it/1lzz8d0
@r_cpp
AI will replace programmers—just not yet, because it still generates very extremely inefficient code.
https://nullonerror.org/2025/07/12/ai-will-replace-programmers-just-not-yet-because-it-currently-generates-extremely-inefficient-code/
https://redd.it/1lzr1zz
@r_cpp
Sourcetrail (Fork) 2025.7.11 released
Hi everybody,
Sourcetrail 2025.7.11, a fork of the C++/Java source explorer, has been released with these changes:
C/C++: Add indexing of `constexpr`
C/C++: Replace most msvc compiler switches with the correct clang switches (Fixes a long standing issue "no such file or directory (sourcetrail is treating MSVC options as file/dir)"
Java: Add support for Java 24
C/C++/Java: Revised the list of keywords for syntax highlighting
https://redd.it/1lzoc6n
@r_cpp
Little adventure in pursuit of errors. The Battle for Wesnoth!
https://pvs-studio.com/en/blog/posts/cpp/1261/
https://redd.it/1lzjoqg
@r_cpp
programming much more enjoyable.
These are the most important advantages for me; there are others, but they're not as important.
The favorite style I us is the following
**Types**
| Postfix | Description | Sample |
| ------------ | ----------- | ------ |
| `b`* | **boolean** | `bool bOk, bIsOk, bIsEof, bResult;` |
| `i`* | **signed integer** (all sizes) | `int iCount;` `int64_t iBigValue;` `int16_t iPosition; char iCharacter;` |
| `u`* | **unsigned integer** (all sizes) | `unsigned uCount;` `uint64_t uBigValue;` `uint8_t uCharacter;` `size_t uLength;` |
| `d`* | **decimal values** (double, float) | `double dSalary;` `float dXAxis;` `double dMaxValue;` |
| `p`* | **pointer** (all, including smart pointers) | `int* piNumber;` `int piNumber[20];` `void* pUnknown;` `std::unique_ptr<std::atomic<uint64_t>[]> pThreadResult;` |
| `e`* | **enum values** | `enum enumBodyType { eUnknown, eXml, eJson };` `enumBodyType eType = eJson;` |
| `it`* | **iterator** | `for( auto it : vectorValue ) {...}` `for( auto it = std::begin( m_vectorOption ), itEnd = std::end( m_vectorOption ); it != itEnd; it++ ) {...}` |
| `m_`* | **member variables** | `uint64_t m_uRowCount;` `std::vector<column> m_vectorColumn;` `uint8_t* m_puTableData = nullptr;` |
| `string`* | **all string objects** | `std::string_view stringName;` `std::string stringName;` `std::wstring stringName;` |
| *`_` | **view declaration** | `boost::beast::http::file_body::value_type body_;` |
**Scope**
| Prefix | Description | Sample |
| ------------ | ----------- | ------ |
| *`_g` | **global reach**, global methods and variables | `CApplication* papplication_g;` |
| *`_s` | **static**, like free functions and static variables within objects and methods with file scope | `static std::string m_stringCity_s;` |
| *`_d` | **debug names**, names that are used for debugging | `std::string stringCommand_d;` |
https://redd.it/1lys9y0
@r_cpp
Hungarian Notation, for us who use it
Note: Most developers aren't fans of Hungarian Notation, and that's totally fine. This thread is for those of us who do use it, and how to make it effective. Let's discuss this niche area; we know we're a small minority
# Hungarian Notation
How do you use this style to maximize your effectiveness? Do you have any tips?
To start I can inform the most important areas for me using Hungarian.
For me, Hungarian Notation is a technique to maximize the speed of visually processing and understanding code. Three main areas for speed
### Filtering out unimportant code
I rarely "read" code, I scan it. My eyes typically focus on columns 5-40 in the editor. I also always have a thin line above each method in *.c, *.cpp files. This line marks where a method begins. This pattern speeds up scrolling through code. My scroll step is set to 10 lines, so the slightest tick on scroll wheel moves me 10 lines up or down. I also use a Logitech mouse with a free-spinning scroll wheel, allowing me to scroll about 500 lines with a single finger movement. The line above each method helps my eye catch the method name when scrolling fast through the code.
example:
/** ---------------------------------------------------------------------------
* @brief describe method
* ...
*/
void names::reserve(size_t uSize)
{
}
iSomeName. All programmers on the team can understand each other's code, and it's easy to read the code even outside of editors._g, instead of starting with gSomeName as many do. This is a less critical marker, more about understanding the consequences of changing a value and comprehending the code as a whole, which is why this type of marking is at the end (its not something that improves speed). Debug and static variables have their own markers, becoming *_d for debug and *_s for static. I always add an underscore "_".
GUESSE WHO LEARNED TO DO A CALCULATOR
>
https://redd.it/1lydyia
@r_cpp
What are good learning examples of lockfree queues written using std::atomic
I know I can find many performant queues but they are full implementations that are not great example for learning.
So what would be a good example of SPSC, MPSC queues written in a way that is fully correct, but code is relatively simple?
It can be a talk, blogpost, github link, as long as full code is available, and not just clipped code in slides.
For example When Nanoseconds Matter: Ultrafast Trading Systems in C++ - David Gross - CppCon 2024
queue looks quite interesting, but not entire code is available(or i could not find it).
https://redd.it/1lxyko5
@r_cpp
How to flatten the variant?
I have `std::variant<std::variant<int, char>, char>` I need to first flatten it and then take the unique types from it. The result should be std::variant<int,char>. How to do that? I have implemented unique\_variant using templates. Also done flattening. But couldn't able to compose them together.
But when I do
using ResultType = unique_variant<flat_variant<std::variant<InnerType<A>, InnerType<B>>>>;
It is giving me type as
std::variant<std::variant<int, char, char>> but I want std::variant<int, char>
template <typename T, typename... List>
constexpr bool is_in_list = (std::is_same_v<T, List> || ...);
template <typename... Types> struct flat_type_container {
using type = flat_type_container<Types...>;
using variant = std::variant<Types...>;
};
template <typename First, typename... Types>
struct flat_type_container<First, flat_type_container<Types...>> {
using type = flat_type_container<First, Types...>;
};
template <typename First, typename... Rest> struct unique_types {
using type =
typename std::conditional_t<!is_in_list<First, Rest...>,
typename flat_type_container<First,
typename unique_types<Rest...>::type>::type,
typename unique_types<Rest...>::type>;
};
template <typename First> struct unique_types<First> {
using type = flat_type_container<First>;
};
template <typename... Types> struct get_unique_variant {
using container = typename unique_types<Types...>::type;
using variant = typename container::variant;
};
template <typename... List>
using unique_variant = typename get_unique_variant<List...>::variant;
template <class T> struct is_variant : std::false_type { };
template <class... Ts>
struct is_variant<std::variant<Ts...>> : std::true_type { };
template <class T> constexpr bool is_variant_v = is_variant<T>::value;
template <class V1, class V2> struct concat_variants;
template <class... Ts, class... Us>
struct concat_variants<std::variant<Ts...>, std::variant<Us...>> {
using type = std::variant<Ts..., Us...>;
};
template <class T> struct flat_variant {
using type = std::variant<T>;
};
template <class T>
struct flat_variant<std::variant<T>> : flat_variant<T> { };
template <class First, class... Rest>
struct flat_variant<std::variant<First, Rest...>> {
private:
using flat_first = typename flat_variant<First>::type;
using flat_rest =
typename flat_variant<std::variant<Rest...>>::type;
public:
using type =
typename concat_variants<flat_first, flat_rest>::type;
};
https://redd.it/1lxyfpa
@r_cpp
Need good resources for learning C++
Believe it or not, I'm a professional C++ programmer. But, we use C++98 and really I'm just passing data around in my day to day coding tasks and not having to design classes/take into consideration best C++ practices (think: there's some existing code, I need you to build upon it with a couple of functions to do something else). My colleagues run laps around me discussing STL stuff like std::optional and a bunch of other standard library stuff. I need to get up to speed (I'm well versed in memory management and embedded C) for when we EVENTUALLY upgrade and all my pushed code is rejected for not being optimal.
There's a bunch of books that teach C++ best modern practices, but these books don't have exercises! It's quite sad, I love learning and then doing exercises to cement it in my head. I know you can just go and write a project etc. etc. but are there any good books/resources for programmers wanting to learn modern C++ which actually tests your knowledge like a college course would? I saw learncpp.com but the endless drolling on very abstract topics like size of data types etc. etc. or going way to deep into something like type conversion makes me lose interest). Thanks.
https://redd.it/1lxz07c
@r_cpp
C or C++
What should i learn now C language or C++.
I have just learnt python
https://redd.it/1lxrajk
@r_cpp
Physics Engine
Project Tachyon: Real-Time Physics, Real Chaos
I’m building a modular, GPU-accelerated 3D physics engine from scratch real-time, constraint-based, and built for soft bodies, chaotic systems, and high-performance collisions. In the last 3 months I've built 2 engines on my own and I'd love to do it with some friends (none of mine understand c++ or newtonian mechanics that well) so im looking for new friends. I’m a physics and CS double major starting small with 3 to 5 devs who want to learn, build, and push boundaries together. If simulation is your hobby or you’re just looking for a challenge, this might be your crew. We’re working in C++ with CUDA and OpenGL, meeting weekly, and sharing code on GitHub. I know this is my passion and I guarantee anyone who wants to jump aboard will find this to be one of the more rewarding projects. It's a great opportunity to learn physics math and low level coding and the very basis for fields like robotics, scientific computing, environmental modeling and of course video games and ‘virtual reality’. DM if you're really interested.
https://redd.it/1lxfck2
@r_cpp