r/Cplusplus

So i was on chapter 3.6 of learncpp.com and i incountered step back in debugging , while for other debugging feature they have told us the shortcut , they haven't mentioned it for step back and have said it's not available in any visual studio community edition as of writing this ie 2019 and even on internet there's not much available about it. So i want to ask someone experienced if it's true for now too (2026)

I new to C++ and im running into this issue when doing a simple print statement please help

Recently I started implemented order matching engine. And for that I initially created a orderbook which stores ask and bids order using map<int, list<order>> and for order id look up unordered_map<order_id, order_pointer>

For the curiosity, I decided to benchmakr the code, without implementing the engine. So I grnerated orders randomly, and directly feeded it to the Orderbook. Then I benchmarked it using the google bench. According to benchmark, I am getting approx1M/s orders [add + delete + modify] in debug mode and approx 7M/s in the Release Mode.

I think there is something fishy. Till now, I have studied some github repository, and none of them have mentioned more than 2-3M orderes per second.

Github Repo :-

Actually my plan was to optimize the order book first by replacing map with flat map and preallocating memory. But now it seems real bottelnect comes from engine not from the order book.

Any suggestion ?

Have you ever wanted to use virtual template functions but found existing methods have so much boilerplate? Ever thought that virtual template functions could be done without it? Well, with the new reflection features, it can be!

The main goal was to minimize the amount of code required to use virtual template functions. This has been accomplished. Each base class needs to inherit only one class, and each base virtual template function requires one line of code to provide the minimal information required. This looks a lot nicer as it is very similar to how normal virtual functions are created.

Simple example:

struct D1;
struct D2;

struct Base: VTF::enable_virtual_template_functions<D1,D2>{
    template<typename T>
    Base(T* ptr): enable_virtual_template_functions(ptr){}

    template<typename T>
    int f(int a){
        constexpr auto default_function = [](Base* ptr, int a){ return 99;};
        CALL_VIRTUAL_TEMPLATE_FUNCTION(^^T,default_function,a);
    }
};

struct D1:Base{
    D1():Base(this){}

    template<typename T>
    int f(int a){
        return 11;
    }
};

struct D2:Base{
    D2():Base(this){}
    
    template<typename T>
    int f(int a){
        return 12;
    }
};

int main(){
    using PtrT = std::unique_ptr<Base>;
    PtrT a = std::make_unique<D1>();
    PtrT b = std::make_unique<D2>();
    assert((a->f<int>(1) == 11));
    assert((b->f<int>(1) == 12));
}

title says it all help a fellow beginner out, I relly need some help me rn why this 100 character limit???

Can someone tell me how use the headers in c/c++? It give the possibility to use it, but I seems it don't work. Only work if I include the c file directly, but I'd want to use the headers.

P.S.: The app's name is "cxstudio" (it's android/mobile)

The code below: (2° update)

main.cpp

#include <iostream>
#include "testing.hpp"

int main() {
    testit();
    return 0;
}

testing.cpp

#include <iostream>
#include "testing.hpp"

void testit() {
    printf("Hello world!");
}

testing.hpp

#ifndef TESTING_HPP
#define TESTING_HPP

void testit();

#endif //TESTING_HPP

Makefile

# Kompilator C++
CXX = g++

all: main

main: testing.o main.cpp
	$(CXX) testing.o main.cpp -o main

testing.o: testing.cpp testing.hpp
	$(CXX) -c testing.cpp

clean:
	rm -f *.o main

Terminal (error) (if run main.cpp directly)

Compilling...

Id.lld: error: undefined symbol: testit()
>>> referenced by main.cpp
>>> /data/data/com.alif.ide.cpp/files/usr/tmp/main-a77af4.0: (main)
clang++: error: linker command failed with exit code 1 (use -v to see invo cation)

Terminal (error)

$ Is
Makefile testing.cpp
main.cpp testing.hp

$ make
g++ -c testing.cpp
g++ testing.o main.cpp -o main

$ main
bash: main: command not found

$./main
bash: ./main: Permission denied

$ chmod +x main

$./main
bash: ./main: Permission denied
$

PCH (Precompiled Headers) is something that doesn't get talked about much in the C++ ecosystem, but it can have a huge impact on compilation times.

It becomes especially useful in projects with a large number of source files, such as game engines, complex desktop applications, or projects with many dependencies.

When compiling a C++ project, the compiler processes headers for every translation unit. Even if those headers rarely change, they still get parsed again and again for each .cpp file. This repeated work adds a lot of overhead to build times.

A good real-world example is a game engine + game project setup.
The engine code usually remains relatively stable, while the game code changes frequently. In that case, it makes sense to compile the engine-related headers once and reuse them, instead of recompiling them every time the game changes.

The same logic applies to the STL (Standard Template Library). Since we rarely modify STL headers, they are a great candidate for precompiled headers.

In many professional projects, PCH is typically configured during project setup by build engineers or senior developers. Most developers working on the project simply benefit from the faster build times without directly interacting with the configuration.

I ran a small demo to compare build times with and without PCH.

Results

Without PCH
Build time: ~162 seconds
Total time: ~2m 50s

With PCH
Build time: ~62 seconds
Total time: ~1m 08s

So roughly 2.6× faster compilation just by introducing PCH.

I also created a small demo repository with the example files and instructions if anyone wants to try it:

Curious to hear how others here handle build time optimization in larger C++ projects (PCH, Unity builds, Modules, etc.).

Hey everyone,

I’m hitting a strange developmental wall and I’m curious how others—especially those mentoring juniors or currently upskilling—are navigating this.

For context, I work at a Big Tech company and regularly touch a massive C++ codebase. I understand the architecture, I can navigate the legacy decisions, and I know my way around modern C++ paradigms.

But I am completely trapped in the "AI Dependency Loop."

The old adage of "just build things to learn" feels fundamentally broken for me right now. The moment I sit down to architect a side project or tackle a complex feature, the initial friction of setting up boilerplate, dealing with CMake, or resolving a convoluted template error makes me reflexively reach for an LLM.

I am stuck in an incredibly frustrating middle ground:

• The Skeptic: I know enough C++ to look at an AI’s output and immediately suspect it. I can spot when it’s hallucinating an API, ignoring memory safety, or introducing subtle Undefined Behavior. I absolutely cannot trust it blindly.

• The Dependent: Despite knowing it's flawed, I don't possess the sheer muscle memory or encyclopedic knowledge of the standard library to just hammer out the implementation at 100wpm on my own. Without the AI, I feel agonizingly slow.

Because I use AI to bypass the "struggle," I am not building the neural pathways required for true mastery. I'm just an editor of mediocre, machine-generated code.

For those of you mastering C++ in the current era:

1. How do you force yourself to endure the necessary friction of learning when the "easy button" is ubiquitous?

2. Have you found a workflow where AI acts as a strict Socratic tutor rather than a crutch that writes the code for you?

3. How do you build muscle memory when the industry demands velocity?

Any harsh truths or practical frameworks would be greatly appreciated.

Would like to also add that I’m expected at my level to move fast and thus just “learn harder” isn’t gonna cut it for me.

I’m currently trying to strengthen my understanding of C++, but I’m a bit confused about the right depth of learning.

There are so many topics involved, like classes/objects, memory management, STL, templates, modern C++ features, multithreading, etc. When I study a concept, I often end up wondering how deeply I should go.

For example:
• Should I just understand how to use features like classes, smart pointers, and STL containers?
• Or should I also study internal details like memory layout, compiler-generated functions, move semantics, vtables, etc.?

Sometimes I feel like I’m overthinking the depth instead of learning things systematically.

So my main questions are:

• How deep should a developer go when learning core C++ concepts?

• Which topics really require deep internal understanding?

• What does a “good” understanding of C++ fundamentals actually look like?

• What resources (books, courses, or articles) helped you understand C++ fundamentals properly?

I’d really appreciate advice from experienced C++ developers on how they approached learning the language properly.

“According to the January TIOBE Index, C++ is currently the fourth most popular programming language after C and Python. C++ is the main programming language used in many critical systems, including hospitals, cars, and airplanes. But dare I say it: C++ is prone to errors. And in 2024, even the U.S. government chipped in. They dropped the bomb: C and C++ are not memory-safe programming languages. In 2026, might C++ be seeing its last days?”
  
 

No, not even close to starting to die.  New projects are being started in C++ daily.

Lynn

Hey everybody. I am working on a 2D game engine in C++ using SDL. So far everything has been working fairly well, but one thing I'm running into at around 3000 lines (as if that really means anything) is includes causing slight changes in certain classes to trigger the recompilation of a bunch of other classes.

I have a class called Globals that stores some static variables like debug booleans for certain render overlays. It also contains the default tile width/height and some other things that I would like to store in a single place. This class is completely defined in the header (which I imagine is the issue).

I use the Globals class in a bunch of different code around the code base, so when I set DEBUG_RENDERING to true, every user of Globals.hpp must be recompiled. How do I get around this while still being able to contain all of these members in the same place? I haven't gotten into macros or other preprocessor directives yet, so maybe that could help? Any direction would be appreciated.

I amn a retired s/w developer. I have loads of C++ source code that I wrote in the 90s and I have a yen to play around with it now that I have the leisure It was written with Turbo C++ and I still have my old copy, manuals + diskettes. But no way of reading the diskettes even if they are readable. I have tried the usual USB diskette readers but they just do not work for me.

I have set up an Oracle VirtualBox environment for DOS 6.22 so it is pretty much what I used in the mid 1990s for personal software development projects. I just need to download the diskettes from somewhere or find a 3.5 diskette drive that actually works. Do they exist?

I have tried internet archive and Embarcadero and just cannot find them. All the links I have found on Redddit and other sites have proved to be defunct

Would appreciate any help in tracking it down Thanks

This is what we will be covering: Major Areas to Study

Major Areas to Study

• Compilation process (editing, preprocessing, compiling, linking, loading)

• Compiled vs interpreted languages

• Data types and variable initialization

• Input/output using cin and cout

• Types of errors (compile-time, run-time, logic)

• Conditionals (if/else, switch)

• Loops (for, while, do-while)

• Tracing loops and nested conditionals

• Functions (pass-by-value vs pass-by-reference)

• Arrays and vectors

• Basic classes (constructors, private/public, getters/setters)

• Exception handling (try/throw/catch)

• Basic string operations

I want to make a simple wrapping library for completing SIMD operations in C++. I want something like this:

size_t SIZE = 1'000'000;
std::vector<float> a(SIZE);
std::vector<float> b(SIZE);

// initialize a and b with some data

std::vector<float> c(SIZE);
foo::add(a, b, c, 0, SIZE);

/*
elements from 0 (inclusive) to SIZE (exclusive) of a and b are added with SIMD operations (see later for how that's done), result stored in c

achieves the same end result as this:
for (size_t i = 0; i < SIZE; i++) {
    c[i] = a[i] + b[i];
}
*/

Upon starting the program, runtime CPU detection will determine what your CPU's SIMD capabilities are. Upon calling foo::add, the library will dispatch the add workload to specialized functions which use SIMD intrinsics to do the work.

For example, if during runtime, your CPU is determined to have AVX2 support but no AVX512F support, foo::add will do the bulk of the addition calculations with 8 32-bit floats at a time in AVX's 256-bit registers. Once there are fewer than 8 indices left in the vector to add, it will fill in the rest of the last 256-bit batch with 0s and discard the unused data. Same idea happens if you have AVX512F support, it does the calculations 16 at a time in the 512-bit registers.

That's the whole idea. I think it'd be pretty useful, and I don't know why it hasn't been done already. Any thoughts?

(less important) Implementation details so far:

I would want to implement as many operations which are supported by the SIMD hardware as possible, including vertical (operations between multiple vectors, like adding each corresponding element in my example above) and horizontal operations (operations within a single vector, like summing all elements into a single sum value).

I would make heavy use of metaprogramming for writing this since it's a lot of repetition and overloading functions for different datatypes. I'd probably make a whole separate program, probably in JS, just to write the library files.

The easiest way to do this would probably be to have three distinct types of functions called for every operation. I call these the frontend, the dispatcher, and the backend.

The frontend in my example is called foo::add, and takes three array/vector types (whether they be std::vectors, std::arrays, references to fixed-size C-style arrays, or pointers to non-fixed size C-style arrays or heap-allocated arrays), a start index, and an end index*****. These would use templates for fixed-size array sizing, but would be manually overloaded for arrays with elements of specific types (so there'd be a separate foo::add overload for floats, for doubles, for int32_t's, etc). The frontend gathers sizing and index info from each array parameter and passes this data to the dispatcher in the form of pointers to the starting element of each array and size information.

The dispatcher checks some const global bool flag variables (which are initialized with the result of a checker function at the beginning of the program) to see which backend functions it can use to actually complete the operations. I tried to make this a while ago GCC/Clang's [[gnu::target("avx, or something else")]], but I want to check the CPU manually this time since GNU attributes aren't portable, and also I was running into problems, I forget exactly what but I think it had something to do with PE executables not fully supporting the feature and GCC playing better than Clang.

The backend functions use SIMD intrinsics to implement the operations. This is where it gets tricky because most compilers seem to have an all-or-nothing approach to implementing SIMD operations. If you want to use SIMD intrinsics in a C++ program, you have to enable it explicitly with the compiler's flags (like "-msse", "-mavx", "-mavx2", etc for GCC/Clang). This allows you to use the intrinsics******. But, it also allows the compiler to use those instructions for any other reason in its optimization efforts, and the compiler can sprinkle these instructions wherever it wants. This makes isolating AVX instructions only to specific functions (which are only called when the dispatcher is certain that the CPU supports these instructions) difficult without using separate source files for every SIMD version type, which I will have to do. I got this all wrong on my first real attempt on this library, which I posted on this sub along with a link to a GitHub repository which I have since taken down as I work on an improvement.

I want to support ARM SIMD types as well, but I will focus on x86 first. I also want to implement a way to specify which SIMD types to implement when compiling the library, to potentially save executable space by not including certain functions. This would of course also require the dispatch functions to change based on these options.

I wish to eventually expand this into a large parallel computing library for SIMD operations, multithreaded SIMD operations, and GPU computing operations with at least OpenCL and CUDA support, all of which autodetect during runtime to speed up operations.

I also have very little experience making larger C++ projects or libraries or running a GitHub repository (which will host this project). Any tips for new people?

*****I want to implement a way where the start and end index for each of the (in this example, 3) array parameters can be tuned individually. So you can for example add elements 2-12 of array A and elements 100-110 of array B into elements 56-66 of array C. Not sure how I'd do that in an acceptable way.

******GCC seems (?) to allow you to use intrinsics for certain instruction set extensions even if those flags are not passed to the compiler. This is super helpful when I am trying to isolate certain instructions only to parts of the code that run after I check the CPU. But it seems Clang does not have this (it might give a warning or an error, I forget), and I don't know about MSVC or any other compilers.

An unimportant detail about older SIMD instruction set extensions:

I could implement MMX or 3DNow operations in addition to the planned SSE, AVX, and AVX512 (doing an additional batch of 2 indices in the 64-bit registers in my example of adding 32-bit floats) but MMX is deprecated, and 3DNow is actually long gone and no longer included in modern CPUs. Both of these 64-bit SIMD instruction set extensions have their sets of 64-bit registers overlayed on top of the 80-bit x87 FPU registers (with MMX focusing on integer operations and 3DNow implementing FP operations), and using x87 at the same time at MMX or 3DNow without calling explicit state-clearing instructions causes issues (although it seems that completing scalar operations on floats is typically done in SSE registers rather than x87 registers nowadays). Since these dated extensions would really only be used very briefly at the end of an SIMD operation on an array/vector, they would probably just take up excess space in executables for very little performance benefit.

But, since I plan on implementing a way to choose which SIMD types are actually implemented when compiling the library, I could easily implement these older types, and just have them disabled by default (so they won't be taking up space in executables). The user of my library could explicitly enable these when targeting older systems.

will the standard Libary in c++ ever be fixed so that it is not anymore implementation dependant on some Features.

ngl i really like C++ and its one of my favourite Language, but i really hate this part about cpp.

In modern C++, small improvements in readability can make a big difference in long-term maintainability.
One simple example is replacing typedef with using for type aliases.
In the example below, it’s not immediately obvious that Predicate is the name of the function type that returns bool and takes an int when written with typedef. You have to mentally parse the syntax to understand it. With using, the intent is much clearer and easier to read. (And yes… saying “using using” is a bit funny 😄)
Since C++11, using has become the preferred approach. It’s cleaner, more expressive, and most importantly, it supports template aliases, something typedef simply cannot do. That’s why you’ll see using widely adopted in modern codebases, libraries, and frameworks.
While typedef still works, there’s very little reason to choose it in new projects today.
Are you consistently using using in your C++ code, or do you still come across typedef in your projects?

Hello!

I am a recruiter at SpaceX and I am on the hunt for talented low-latency C++ programmers.

The Satellite Beam Planning Team is fully onsite in Redmond, WA and they work on optimizing our constellation. They tackle fascinating challenges involving the beams being cast down to earth, and how satellites communicate via laser links amongst themselves. This is a massive latency/optimization problem we are solving!

What sets top performers apart is rock-solid fundamentals that we can build upon.

Key topics that align well:

•            Computer Architecture

•             C++ (performance-focused, beyond OOP)

•             Algorithms (with emphasis on Linear Algebra and Trigonometry)

•             3D Geometry and Vector Math

•             Assembly and x86

If you are interested, apply!!

hi, in new to programming and started with C , i used C Programming: A Modern Approach 2nd ed. Edition by k&n and liked it , but i wanna shift into c++ as C as i need oop , as i said im still new , so something that will go through the basics but as well spend time in harder stuff like memory ...

I need to be able to answer very simple questions. There will be no coding questions.

- How does the object oriented programming differ from structured programming?

- With example, explain the multiple inheritance and function overloading in OOP. Also, list the operators which cannot be overloaded.

- Why is inheritance required in OOP? Explain different types of inheritances with suitable diagrams

-  How does ambiguity arise in Multipath inheritance? How can you remove this type of ambiguity? Illustrate it with suitable example

- Explain constructor and destructor call sequence in single and multiple inheritance in CPP.

Questions are of this level. So you get the gist. I want a proper book which covers these topics. I tried robert lafore cpp book but it was not to the point.

I learned how the Swift language has changed things with switch statements and I was wondering if others would like a "swift" attribute that could precede the switch keyword.

This says:

attr (optional) switch ( init-statement (optional) condition) statement

But I didn't see any attributes in the following page that would be a different name for "swift" or that make sense to use prior to the switch keyword.

An example of the code would be:

[[swift]] switch (rc){
case 3:

case 4:

default:
}

Where only one case is executed and break statements aren't needed. Support for something like this would help me get rid of a number of lines of code. Thanks in advance.

PVS-Studio presents a series of webinars on how to build your own programming language in C++. In the first session, PVS-Studio will go over what's inside the "black box". In clear and plain terms, they'll explain what a lexer, parser, a semantic analyzer, and an evaluator are.

Yuri Minaev, C++ architect at PVS-Studio, will talk about what these components are, why they're needed, and how they work. Welcome to 

i’m in a college level c++ coding class. i use VS. my current assignment includes attaching .txt files to be used and referenced by my code. i cannot for the life of me get the app to run, it just keeps spitting out “error opening file” even though i’ve added the file to the solution.

anyone able to help me figure this out?

Pretty deep, but don't learn it the hard way guys. Even though im pretty sure in general, C and C++ developers read more documentation than for example higher level languages, but still treat this as a reminder.

Hi everyone. I’m doing requirement analysis for a graduate capstone. The project is a backend/application-layer caching component intended for services that expose both gRPC (protobuf) and REST/JSON.

I’m collecting quick input to prioritize requirements and define acceptance criteria (performance, correctness, operability). I’m not looking for code just what experienced engineers would rank as most important. If you can, comment with one real incident you’ve seen (stale data, stampede, debugging nightmare, security issue, etc.).

Poll: If you could prioritize only ONE requirement area first, which would it be?

Hello everyone.

I'm currently working on a ~10 years old software written in C++, with a team (including myself) that is used to work mostly with C++17 features, and a tiny sprinkle of C++20 here and there (mostly ranges and basic coroutines).

I come here looking for recommendations on resources, be it online content, books, or personal wisdom, that can ignite sparks of curiosity and desires to push for modern coding C++ practices in my team. Starting from C++20 itself.

I know I can go and browse all new features for major versions, but I would love to read about their real-world impact on your projects.

What content have you read that left you like "wait, can I do that!?"?

What feature or trick has proven to be more useful for you in the last couple of years?

What helped you in your latest refactoring of legacy code?

Any piece of advice is highly appreciated. Thanks.

I'm trying pretty hard to find a way on how to print the character "ö". I've tried using 'char(246)', which printed '÷', I've tried using unicode, 'cout << "\u00F6";', and it prints '├Â', I've also tried searching about this through chat gpt but same thing happens, I've also looked up ASCII tables but I can't seem to find the lower-case version (Attached the image of where I looked at). Any help?

Hey,

Interested in feedback and generally just sharing this library if anyone wants to try use MQTT in their project.

I come from a game dev background and recently had to work with MQTT, so I decided to write my own MQTT 5 C++ client library in my spare time as a way to learn what it’s like to design and ship a library end-to-end.

I’ve tried to keep the design game-dev friendly and cross-platform (with future console support in mind). I started this early last year, working on it in small chunks each week, and learned a lot about library architecture and portability along the way.

There are still things I plan to improve when I got a bit more time from my next hobby project, for example:

• Abstracting threading/timing instead of relying directly on std::thread / std::chrono (similar to how sockets are handled)

• Supporting custom memory allocators

• Removing a couple of unnecessary heap allocations

Uses:

• MQTT 5

• C++14 compatible

• CMake for builds

Testing is currently unit tests + a sample app (no real-world integration).

Thought I'd share it here, I'm happy to receive feedback, and feel free to use it:

Thanks

I need the kilograms to be to two decimal places. The answer should be 19958.07 NOT 19958.1

I cannot figure out what to do. I am not allowed to use set precision or anything that we haven't learned in class. This is the only way I know how to do this without set precision.

It's a little simple,it's just something that allow you to modify your terminal text color and style,but im planning on making a library that allow you to create GUI

For me it was that 'private','public' and 'protected' keywords are only compile time and

class Foo{
private:
int Bar;

};

&

class Foo{
public:
int Bar;

};

produce the same binary

I've always wanted to know what the difference between these two are. i've seen many posts about how one is better or about how the other is better... honestly the `while (true)` is way more readable. do they produce different assembly outputs even?

I am trying to make a 3D game using 20-year-old software (Mesa & OSMesa 6.5, SDL 1.2.15, OpenGL 1.5, MSVC++2005 on XP SP3) that runs on 20+-year-old hardware. I have gotten up to the point where I have gotten a spinning cube to spin in place in a window. I have also tried to do some video API abstraction (i.e. putting abstracted calls to the Mesa/SDL functions into platform_win32_sdl.h). The hardware mode uses SDL to create an OpenGL window and draws to that, but the software fallback I wrote uses the regular Win32 APIs (because I wasn't able to blit the OSMesa framebuffer to an SDL window) and OSMesa (software rendering to just a raw bitmap framebuffer in RAM). The hardware mode works great and runs on OSes as old as Win98SE if I install the Windows Installer 2.0 (the program that installs MSI files, not the program that installs Windows itself) and the MSVC++2005 redist. but the software mode (which I only implemented just in case I need it when I port the game to other platforms) will only render the glClearColor but not any of the 3D cube. I find it interesting that it is rendering the background clear color (proving that OSMesa is infact working) but the 3D cube won't render, how do I fix that?

Download the code and the compiled EXE using The SDLTest.exe in the debug folder does not work correctly but the SDLTest.exe in the release folder works correctly, and I have put all the required DLLs minus the VC redists in there for you. The options.txt in the same directory as the SDLTest.exe will allow you to switch between hardware OpenGL and the currently non-functional software OSMesa modes by editing the first line of the text file to "renderMode=hw_opengl" or "renderMode=sw_osmesa".

I went over the code several times and never found anything wrong, and none of ChatGPT's advice was able to help me either. If you have any more questions or comments about my build setup, feel free to ask!

I am new to c++ and I have zero clue on how to learn it so I wondering how did some of you learn it and can I get tips and help anything would be appreciated

Hello everyone 👋🏼,I have an ML compiler interview scheduled in a week. I've already completed the initial coding assessment and a coding interview. The recruiter mentioned the next round will focus mainly on C++. I have a basic idea of what to expect, but I'm unsure about the depth they'll go into. If anyone has recently gone through this interview process and can share their experience, it would be really helpful!

A question for template experts, regarding the deducing of function argument types. I'm making a function similar to std::format, it should accept a constant string literal and a set of arguments for substitution as input. During compilation, it is necessary to parse the string and prepare an array with a description of the substitution parameters. And for this, I would like to get both the length of the substitution string and the number of arguments as compile-time constants in one parameter during compilation. But I can't describe the parameter in such a way that the compiler can deduce the required type. It only works if I duplicate the substitution string twice:

template<typename T> struct const_lit;

template<size_t N>
struct const_lit<const char(&)[N]> {
    enum {Count = N};
};

template<size_t PatternLen, typename ...Args>
struct param_info {
    // Information about a portion of the pattern - this is either a piece of the pattern of length `len`, starting from `from`, or an argument with index `from`.
    struct portion {
        portion() = default;
        unsigned from: 16 = 0;
        unsigned len: 15 = 0;
        unsigned is_param: 1 = 0;
    };
    // A string of length PatternLen can have a maximum of 1 + (PatternLen - 2 * 2 / 3) portions (PatternLen includes 0)
    // For example "-{}-{}-{}-" - one portion of one character at the beginning of the string and two portions for every three characters.
    // PatternLen == 11, portions: [0, 1] [p0] [3, 1] [p1] [6, 1] [p2] [9, 1]
    portion portions_[1 + (PatternLen - 2 * 2 / 3)];
    unsigned actual_used_{}; // Here we will save how many portions actually turned out during pattern parsing

    consteval param_info(const char(&pattern)[PatternLen]) {
        // parse pattern, fill portions_ and set actual_used_
        .....
    }
};

template<typename T, typename...Args>
constexpr auto subst(T&& dummy_for_deduce, const param_info<const_lit<T>::Count, std::type_identity_t<Args>...>& pattern, Args&&...args) {
    /// We take the pre-calculated portions_ from the pattern and fill the result based on the information in them
    ......
}

#define SUBST(par) par, par

void test() {
    // This works
    subst(SUBST("test {2}, {1}"), 1, 2); // Expands into the construct -> subst("test {2}, {1}", "test {2}, {1}", 1, 2);
    // Based on the first "test {2}, {1}" - Count = 14 is deduced, based on 1, 2 - int, int is deduced.
    // Then all the types for the second parameter become known, and the second "test {1}, {2}" is converted to
    // param_info<14, std::type_identity_t<int>, std::type_identity_t<int>>
}

Is it possible to achieve the same, but using the pattern only once? The point is that I need to know the length of the pattern string as a compilation constant in order to use it to calculate the maximum size of the array of portions of information about the pattern. One solution is to simply ignore the length of the pattern, and either just take a large size in advance array:

    portion portions_[128];

which leads to unnecessary waste of memory, or focus on the number of arguments:

    portion portions_[sizeof...(Args) * 2 + 1];

but this will not work with patterns like "{1}-{1}-{1}-{1}".

I made an option with using the pattern once, as in std::format, where at the compilation stage the template string is only checked for correctness, and then at runtime it is parsed again every time, but this loses in execution time by about two times, judging by (the last and penultimate option)

Hey everyone,

A friend and I were joking about premature optimization in hobby projects that will never see the light of day. You know, scaling projects for 0 reason or trying to get the fastest algorithm for the simples of the problems. The joke lead us conversation converged into the next question: What is the theoretically fastest way to calculate the square root of an integer in the range [0, 100]?

A friend suggested [Square Root Decomposition](), but that a huge algorithmic solution for such an small data problem. I’m looking for something that is better at this. I know some of you are way smarter and come up with solutions to this kind of problems that are way better. The only constraint is that you can not precompute all the solutions before hand, that would make the problem extremely easy.

Good luck with this! We are not smart enough or know enough math to come to a good solution, but I was wondering if any of you could give a better solution than the above. Thanks for reading! :D

I feel like AI is excellent with kindergarten level languages like Python, Javascript/Typescript, etc. but not as good with professional languages like C and C++?

Do you need some help learning C++ or help with a beginner or intermediate homework coding assignment with C++ (or potentially other coding languages depending)? Just to add, for homework assignments and such, I obviously can't do it for you, but I can guide you and answer questions. I am newly graduated with a CS degree from U of M. I really miss the basics. So if you need some help, let me know! (Just to add, this isn't like for money or anything.)

PS- Perhaps it's an odd offer, I just had a lot of fun helping an online friend when he has questions or is working on an project, as he's learning to code with c++ for funsies and in prep for an upcoming class that he'll be starting soon.

THIS IS NOT FOR MONEYS. This is because I need a distraction and think it is fun to help with stuff and miss the basics.

Hi! From time to time, I develop simple programs for personal needs and beyond in C++ (more as an architect than a programmer). Usually, they are about 2-3 thousand lines of code, sometimes more. Essentially, it involves various audio and image processing, etc. In other words, these are tasks of medium complexity - not rocket science, but not a simple landing page either.

In general, I usually use Gemini Pro, and when it starts acting up (it often likes to skip a block, delete a block, or mess with other parts of the code while fixing one specific part, etc.), I go to Microsoft Copilot (as far as I know, it uses ChatGPT 5+). If that doesn't work either, as a last resort (which helps in 90% of cases), I go to Claude. Sonnet 4.5 handles what I need perfectly.

Now I’ve decided to buy a subscription, but I saw a lot of complaints about Claude - there was some kind of outage or glitch. On the other hand, I know that Codex exists. And it’s unclear to me which product would suit me better. Unfortunately, you can't try Codex anywhere before buying.

Essentially, I need the following:

1. To write code based on manuals and instructions as the primary vector.

2. To be able to discuss project details in plain human language, not just technical terms (since I am less of a programmer than the AI and don't have instant access to all the world's knowledge).

3. To avoid the issues Gemini Pro sometimes has (laziness, deleting code blocks, modifying unrelated parts of the project... it really likes to break things sometimes).

I use the web interface (since the frameworks I use usually allow me to edit a maximum of 3-4 code files), if that’s important. It might seem funny to real professional programmers, but nevertheless.

The question is-which one would actually suit my tasks and requests better, after all? Sometimes I hear that Codex is more accurate, while there are complaints about Claude; but on the other hand-despite the technical issues (at times) - I feel comfortable with Claude. I can't afford two subscriptions right now. So, what should I choose?

Please share your experience (especially if you have used or are currently using both products).

P.S.: What version of ChatGPT is used in MS Copilot? And is this version far from Codex in terms of programming knowledge? How far?

Over the past months I’ve been experimenting with something that started as a personal engineering challenge: embedding native CUDA execution directly into a high-level language runtime, specifically PHP, using a C/C++ extension.

The motivation wasn’t to compete with existing ML frameworks or to build a production-ready solution, but to better understand the trade-offs involved when GPU memory management, kernel compilation and execution scheduling live inside the language VM itself instead of behind an external runtime like Python or a vendor abstraction such as cuDNN.

One of the first challenges was deciding how much abstraction should exist at the language level. In this experiment, kernels are compiled at runtime (JIT) into PTX and executed directly, without relying on cuDNN, cuBLAS or other NVIDIA-provided high-level components. Each kernel is independent and explicit, which makes performance characteristics easier to reason about, but also pushes more responsibility into the runtime design.

Another interesting area was memory ownership. Because everything runs inside the PHP VM, GPU memory allocation, lifetime, and synchronization have to coexist with PHP’s own memory model. This raised practical questions around async execution, stream synchronization, and how much implicit behavior is acceptable before things become surprising or unsafe.

There’s also the question of ergonomics. PHP isn’t typically associated with numerical computing, yet features like operator overloading and attributes make it possible to express GPU operations in a way that remains readable while still mapping cleanly to CUDA semantics underneath. Whether this is a good idea or not is very much an open question, and part of the reason I’m sharing this.

I’m curious how others who have worked with CUDA or language runtimes think about this approach. In particular, I’d love to hear perspectives on potential performance pitfalls, VM integration issues, and whether keeping kernels fully independent (without cuDNN-style abstractions) is a sensible trade-off for this kind of experiment.

For reference, I’ve published a working implementation that explores these ideas here:

This is still experimental and very much a learning exercise, but I’ve already learned a lot from pushing GPU computing into a place it doesn’t normally live.

While learning DSA and backend fundamentals, I noticed something interesting: I understand concepts much better when I try to explain them in very simple terms.

Recently, I’ve been experimenting with short explanations (30–60 seconds), focusing more on intuition and common mistakes than full code.

I wanted to ask:

• Does learning by teaching work for you?

• Do short explanations help, or do you prefer long tutorials?

I started sharing these explanations publicly to stay consistent. The page is called CodeAndQuery (not promoting—just context).

Would really appreciate thoughts from people who’ve been learning programming for a while.

We published a 64-page report about the European IT job market. It’s based on survey answers from over 15'000 IT professionals and data from 23'000 job posts across Europe.

It covers salary benchmarks in seven European countries, including C/C++, as well as recruitment realities, AI’s impact on careers, and the challenges junior developers face when entering the industry.

Check out the full report (No paywalls, no gatekeeping):

// OC - The Spell

for (long Fn = 0, NI = 1, NJ = 1; Fn >= 0; NJ = (std::cout << Fn << std::endl, Fn = NI, NI = NJ, Fn + NI));

Well I learnt a bit of python in the past, and used to do web dev(all of this is as a hobby since i'm still in HC), and even went further and learnt react and nextjs, till I really got burnt out since it was pretty much mostly UI, which can sometimes be frustrating(people who do web dev can def relate).

But honestly, I'm QUITE ENJOYING IT. I finally feel that I'm actually programming, I feel that i'm understanding how actually code works, I feel I'm actually learning and being productive, and it's just satisfying. It's been only about 2-3 months, but I've got to say I went quite a long way, and since then, it's been a stable part of my day. And I never imagined I would ever have to read A BOOK to learn a programming language, and yeah sometimes stuff is frustrating, but when it finally clicks, it's just awesome.

Hey folks! I've been assigned into a project where I have to make a lot of plots on some algorithms. After reviewing the implementation I have found a huge bottleneck between executing the algorithm and generating the animation that visualizes the execution.

The current implementation is writing all the generated data when executing the algorithms into a JSON file. Then reading this JSON file from a python script that uses maptlotlib to generate the plots to eventually construct a video animation with FFmpeg.

Not only this 3 step process slows down the execution by a lot but also ends ups generating huge JSONs that occupy 11MB per file (the algorithm uses a lot of matrixes). I have already tried to use the GNU libraries for plotting but I don't find the results really good. I have already checked the library wrappers for matplotlib in C++ such as matplotlib-cpp but I don't like the idea of them using python under the hood, as it is essentially doing the same thing but removing the JSON storage part.

Any recommendations for optimizing this pipeline ? There has to be a better way of plotting this. Extra points if someone discovers how to do the ffmpeg thing while the algorithm is executing.

Extra question: Is there any better format of storing this information ?

I kept hearing that some here don’t like the std lib, boost too. Why? I’m curious as a beginner who happens to learn some std stuff just to get my feet wet on leetcoding.

Bro I can't even think about getting back to C. The standard library just makes life sooo much easier, and the more you learn, the more you get satisfied.

The following is the event loop of the of my code generator. It's 53 lines long and uses a number of else ifs. I think switch helps to convey the big picture, but it would add 8 lines to my event loop. Would usingswitch be a good idea here? Thanks in advance.

  ::std::deque<::cmwRequest> requests;
  for(;;){
    auto cqs=ring->submit();
    for(int s2ind=-1;auto const* cq:cqs){
      if(cq->res<=0){
        ::syslog(LOG_ERR,"%d Op failed %llu %d",pid,cq->user_data,cq->res);
        if(cq->res<0){
          if(::ioUring::SaveOutput==cq->user_data||::ioUring::Fsync==cq->user_data)continue;
          if(-EPIPE!=cq->res)exitFailure();
        }
        frntBuf.reset();
        ::front::marshal<udpPacketMax>(frntBuf,{"Back tier vanished"});
        for(auto& r:requests){frntBuf.send(&r.frnt.addr,r.frnt.len);}
        requests.clear();
        cmwBuf.compressedReset();
        ring->close(cmwBuf.sock);
        ::login(cmwBuf,cred,sa);
      }else if(::ioUring::Recvmsg==cq->user_data){
        ::Socky frnt;
        int tracy=0;
        try{
          auto spn=ring->checkMsg(*cq,frnt);
          ++tracy;
          auto& req=requests.emplace_back(ReceiveBuffer<SameFormat,::int16_t>{spn},frnt);
          ++tracy;
          ::back::marshal<::messageID::generate,700000>(cmwBuf,req);
          cmwBuf.compress();
          ring->send();
        }catch(::std::exception& e){
          ::syslog(LOG_ERR,"%d Accept request:%s",pid,e.what());
          if(tracy>0)ring->sendto(s2ind,frnt,e.what());
          if(tracy>1)requests.pop_back();
        }
      }else if(::ioUring::Send==cq->user_data)ring->tallyBytes(cq->res);
      else if(::ioUring::Recv9==cq->user_data)ring->recv(cmwBuf.gothd());
      else if(::ioUring::Recv==cq->user_data){
        assert(!requests.empty());
        auto& req=requests.front();
        try{
          cmwBuf.decompress();
          if(giveBool(cmwBuf)){
            req.saveOutput();
            ring->sendto(s2ind,req.frnt);
          }else ring->sendto(s2ind,req.frnt,"CMW:",cmwBuf.giveStringView());
          requests.pop_front();
        }catch(::std::exception& e){
          ::syslog(LOG_ERR,"%d Reply from CMW %s",pid,e.what());
          ring->sendto(s2ind,req.frnt,e.what());
          requests.pop_front();
        }
        ring->recv9();
      }else ::bail("Unknown user_data %llu",cq->user_data);
    }
  }

Heya! It's me again! I'm currently working on a complete refactor of my old DND game I had made now a year ago. At the time, I had just started programming and barely knew anything (not that I'm an expert or even mediocre now, I'm still a novice). I'm having a bit of a conundrum. I'll simplify the problem (there are many more variables in actuality, but the core of the issue can be explained with barely 2).

struct Base_weapon {
    string name;
    string power_suffix
    int damage;
    Base_weapon(string name, string power_suffix, int damage)
        : name(name), power_suffix(power_suffix), damage(damage) {}
    virtual void weapon_ability() = 0;
};

so I have a basic struct, from which I have 2 derivates.

Common_weapon {
    using Base_weapon::Base_weapon;
    void weapon_ability() override { std::cout << "nothing"; }
};
struct Flaming_weapon {
    using Base_weapon::Base_weapon;
    void weapon_ability() override { std::cout << "flames"; }
};

Base_weapon will be inserted in another struct

struct Player {
    Base_weapon* weapon1 = nullptr;
    Base_weapon* weapon2 = nullptr;
    Base_weapon* weapon3 = nullptr;
    Player(Base_weapon* w1, Base_weapon* w2, Base_weapon* w3) :
        weapon1(w1), weapon2(w2), weapon3(w3) {}
    void special_abilty() = 0;
};

aaand Player has a derivate, Mage

struct Mage : Player {
    using Player::Player;
    void special_ability() override { //here lays the problem }
};

This is the core of the conundrum. The Mage's ability is to "enchant" a weapon, AKA making it go from Common_weapon to Flaming_weapon. The only problem is that I've got no idea how to do this. Say I have a Common_weapon sword("sword", " ", 3) , how do I turn it into a Flamig_weapon flaming_sword("sword", "flaming", 4) while it's actively weapon1 in Player?

Is it even possible to do such a thing?

Hi everyone,

A question: if I have a std::vecror<mystruct> and inside mystruct I have another std::vector<sometype>, if in the constructor of mystruct I do .reserve(100) of std::vector<sometype>, by doing .reserve(10) of std::vecror<mystruct>, will I also have implicitly reserved the memory .reserve(100) for std::vector<sometype>?

Does .reserve() work recursively?

Thank you

I have been trying to compile this simple Hello World code, but it keeps saying build failed, and I don't even know where the issue is. Pls help me have a look and let me know where I faltered.

NB: I am using a Micrososft Visual Studio 2010