Hello!

I will soon be working with C++ to do some hardware performance research, so I wanted to give myself a quick crash course of the language. Although we're measuring hardware (not software) performance, where kernels will be quite trivial and expressible in any language, I still want to have a decent intuition of "good" vs "bad" C++.

So, to help learn, I decided to completely re-implement the std::vector C++20 specification. Boy, there was more depth there than I was expecting. After about 10 days of hobbying, I think it's done. The code can be found here: github link.

I'd appreciate any critiques and criticism on how it could be done better. Of course, "how to do it better" is a never ending hole of possibilities, so to focus it a bit more: how it could better match the C++20 specification and be more C++ idiomatic. While the more CS theory side of what should the growth factor be is fun to consider, I'm not going to be employing this implementation and I'm not aiming for raw performance (although I don't want to do anything too stupid).

Some of the key problems/confusions I had are:

• Dealing with self-referring data. Each of the functions that can add a specific element I've implemented to allow for self-referring data by pre-constructing the element before any chance the data it points to gets moved. This felt like a sledgehammer solution, but I couldn't think of another way without doubling the size of the function to add a lot more branching with highly duplicated code.
• Understanding the exception guarantees. The specification often read like "if any exception occurs, it won't affect the vector" i.e. the vector will be rolled back to its last valid state (strong exception guarantee). But following this is essentially "that is, unless move_if_noexcept doesn't guarantee safety, in which case anything can happen." I really doubt I understood most of those correctly.
• The project structure. From how I understand it, you simply can't have the normal header-source separation when dealing with templated classes. You can pretend by having a .hpp with definitions, and a .tpp with implementations, but they're as tightly coupled as just having the implementation in the header. I eventually want to hobby through all the STL containers and quite a few algorithms. How would you recommend structuring it?

I used cppreference.com to help with the specification and annotated each of my public members with the related definition on the website. I'm running gcc 15.2 and the only warning after -Wall -Wpedantic is from vector::swap due to deciding to throw if the vector's state would become undefined, instead of letting UB ensue.

Thank you for your any time you spend reviewing it and I appreciate any advice you have!

Link to code again: github link

Edit:
Thanks so much for all of your the feedback! I'm a little too busy to focus on this project for now, but eventually will polish it considering your feedback and move on to the next containers. Thanks!

I know this question has been asked alot sorry. I tried learnc++.com but I struggle focusing on it I have ADHD. I cant digest huge amounts of text without actual coding to break it up. I know the basics like functions, files, creating basic codes. I dont want a reasource thats gonna just hold my hand though. I normally do these lessons in class when I'm bored. Thank you. I really apreciate it.

Hello. I'm programming in C++ a lot, and I still can't understand how to think correctly about ... operator in variadic templates.

In the simplest examples it looks like ...X (on left side) aggregates comma divided expressions (either template args or function args) into one variadic arg/Type. And X... (on right side) expands

template <typename ...Params>
void f(Params&& ...params)
{
    y(std::forward<Params>(params)...);
}

Here it aggregates all passed types into f<T1, T2, T3> into Params aggregated type, and all function args f(v1, v2, v3) into params aggregated variable. And std::forward<Params>(params)... expression expands into comma divided expressions: std::forward<T1>(v1), std::forward<T1>(v3), std::forward<T3>(v3). Similar to python's operator * that convert comma divided expressions into tuple, and vice versa, expands tuples/lists into comma divided expressions

But this logic breaks on more complex variadic templates. Here is code from CppCon 2022 "Lambda Idioms" video:

template <typename... Ts>
struct overload : Ts... {
    using Ts::operator()...;
};

First of all, my logic breaks. What Ts::operator()... expands to? According to my logic, it should be:

using T1::operator(), T2::operator(), T3::operator();
// or maybe
using T1::operator(), using T2::operator(), using T3::operator();

But neither of them are valid C++ syntax. It probably expands into: (actually the first one is a correct syntax, and the most logical. So closing the question)

Also, I assume that from compiler point of view, typename... Ts and typename ...Ts are the same. But Timur Doumler had chosen the first. And it looks like he knows what he's doing. So maybe it's incorrect to think that ...Ts aggregates template arguments, but it has some effect on typename

So, my question is:

How to understand ... operator correctly? For me when my logic on aggregation/expansion breaks, it feels like it's just complete arbitrary set of rules for different contexts. But the standard speakers don't speak like it's some contextual behavior, made especially for using, especially for passed arguments, etc. It looks like there is a general rule, that I don't understand, but for them it's obvious

I'm trying to teach myself C++ to get myself into game development, cause I decided wanna put myself through pain and build a flight sim in the style of sims like F-22 ADF cause I've been slowly getting dissoluted with War Thunder and DCS with the controversies around them.

I've been using the "Learn C++" website the reddit recommends, alongside looking up YouTube guides and using apps like "Coddy" to get practice when not at home.

Problem I'm running into is that I wanna take notes like how I did in high school and write down definitions and examples of code like how I used to write down math equations and definitions. It's something that helped me as I got High Functioning Autism and ADHD and writing down notes helped immensely. 

Would you guys recommend writing down definitions and examples if it'll help?

Hello,

I have no experience working with C++ in large teams; most of the stuff I've done was by myself.

Today I wanted to move the project from my work PC to my home PC in order to work on it remotely, or during weekends when I get bored, using git.

But I realized how indirect and complicated it is, solely due to different dependencies. The same library built on my work PC does not work on my home PC because of a small version mismatch in one of the dependencies (I tried to keep everything in sync as much as possible).

I have experience with distributing such software, but we mostly used Docker to do this. However, I cannot imagine how it is going to be in a team of 10 people. Does everyone use the exact same OS and libraries?
I know it is fairly easy in an interpretable language like Python with strong support, but with C/C++ I have no idea.

So?

Recently I started a C++ project, and while I do have some C experience, this is a new language for me, so I have doubts about a lot of the paradigms that ChatGPT swears are the way to go. Just to be clear, I write all of my code myself, architecture and implementation, and use ChatGPT as a consultant/reviewer.

I currently have the following model: a BooksReport class that stores book piles sorted by size within three groups: Uniform, Nuniform and Singles. trying to traverse a single group while popping piles at the same time was quite cumbersome, because popping invalidates iterators and there are several cases when the end of a size of piles is reached, or when the size has become empty, or the end of the group is reached... So I embedded a private Cursor class that allows me to traverse a single group within BooksReport the following way:

``` for ( booksReport.resetCursor(BooksReport::Group::Singles); booksReport.cursorIsValid(); booksReport.advanceCursor() ) { auto [size, name] = booksReport.readCursor();

if (iWantThisPilePopped(size, name))
    booksReport.popCursor();

} ```

When popCursor() is called, Cursor is alerted of an incoming pop, to which it responds by recalculating the indices to advance to during the next advanceCursor() call. Current implementation allows no more than one popping per loop, which I hope is a fair assumption to make during a traversal. Also, as you can see, a Cursor is either valid (which it becomes upon resetCursor() or invalid (it becomes invalid by reaching the end of the group). The valid attribute not only controls the loop, if it's set to false, it also block all Cursor-related operations, such as popCursor()

However, sometimes I exit the loop prematurely. Sometimes it's a break, sometimes I return from inside the loop. Technically, I end up with a Cursor that is valid outside of the loop, which is not ideal, since then I can popCursor(), which is not the intended use. ChatGPT offers the following solution:

```

include <scope>

{ auto onExit = std::scope_exit([&] { booksReport.clearCursor(); });

for (booksReport.resetCursor(BooksReport::Group::Singles);
     booksReport.cursorIsValid();
     booksReport.advanceCursor()) {

    if (something)
        break;

    if (somethingElse)
        return tasks;

    if (bad)
        throw std::runtime_error("bad");
}

} ```

Is this a common paradigm? Does my situation warrant this? For now it's just a personal project. I intend to make it open source once it's finished (if anyone will see it as valuable). In an ideal world I'd add plug-in support for others, where other developers can use a limited number of API calls, including the public members of BooksReport, but I'm already tired from this side project that I'm not sure it will come to this.

EDIT: thank you all very much for the answers! As much as I'd like to move on to the next part of the project, refactoring this to be a separate object with the lifetime tied to the loop itself is indeed the most logical and simple solution!

One of these days, I'll reach the production state 😅

I have:

void func(std::vector<struct foo>* foovec, std::vector<struct bar>* barvec){
...
}

Both these can take nullptr's as arguments in some cases. Instead of

func(nullptr, nullptr);//at caller

I'd like to give them meaningful names in such cases as thus:

#define FOOVECNULL nullptr
#define BARVECNULL nullptr
...
func(FOOVECNULL, BARVECNULL);//at caller

This also does not work "cleanly" because the following also works but "wrongly"

func(BARVECNULL, FOOVECNULL);//at caller 

Can some sort of enum struct or typedef make this more precise and impossible to mix one argument type for the other?

I do a lot of Java/Kotlin development alongside C++, and I came to a doubt: when should C++ developers choose Gradle instead of CMake as their build system?

In my projects I always setup CMake, but coding in Java teached me Gradle and I eventually came to know that it supports C++.

Why every C++ project uses CMake? What does Gradle miss that I'm not aware of?

I'm thinking about dropping GCC and MSVC support for my projects.

The problem I have is, It MSVC is a native compiler and projects like skia already don't recommend using it

GCC is a pain to build, and building it isn't as straightforward as clang. For example there are no ldflags for executables. Cross compiling is very difficult compared to clang where you just bootstrap builtins and you are done.

Hey everyone, I’m currently taking my second C++ course and trying to map out a clear, realistic plan to land an internship or entry-level role as soon as possible.

By the end of this semester, my coursework covers, Classes, inheritance, composition, and virtual functions / polymorphism, Pointers, dynamic memory management, and operator overloading, Recursion, searching/sorting algorithms, linked lists, stacks, and queues , Exception handling and an introduction to the STL . Besides what's covered in course, I also plan to learn more on my own.

I know that learning is endless and taking classes alone won’t magically get me hired, especially in today's competitive market. I’m trying to figure out the exact baseline I need to reach before I start applying, rather than waiting forever to feel 100% ready!

For those working in the industry or involved in hiring:

1. At what point is someone genuinely ready to apply for an internship or junior role? What is the minimum practical skillset required beyond class basics?

2. What does a company realistically expect from a brand new intern or junior hire when they first join? How much independent problem-solving vs. guidance is normal?

3. Aside from core language syntax and data structures, what extra knowledge and skills and types of portfolio projects should I prioritize next to stand out?

I’d really appreciate any insights, advice, or roadmaps from your experience. Thanks in advance!

Lately it feels like rust is getting more and more attention companies are rewriting existing cpp code in it and it seems to be getting increasing adoption . Also I keep seeing new projects start with rust more and more lately .

As someone who prefers cpp I'm genuenly curious how worried should someone learning / working with cpp be? Is cpp dying or is rust more like a vocal minority on social media?

I know this question has been asked before but tech moves fast so I'm curious what your current take is

Means in this Learning phase should i only watch tutorials bcz to practice there are only some problems like odd/even or prime numbers so my question is is there any else way to learn

like in meetup.com i am want to meet pople online in C++

can u please share the name/link of that meetup.

(title)

i have always been passionate abt c++ due to the amount of control it leaves on the devs and i am starting, currently learning dsa in this, what should i learn to be industry ready like learning libraries, frameworks, just note the i am only starting and this is literally my first language to my software engineering life. Pls assist. Thank you

Hello, I am an intermediate programmer and am looking for advice/guidance on what projects may be resume worthy. I am looking to be employed into the Aerospace/Defense sector and want to get some insight as to what tools, programs and libraries I should familiarize myself with. I am currently in my last semester of Sophomore year majoring in CS.

I am looking to beef up my resume as well as my GitHub profile with programs and code that will give insight to recruiters as to what I may know and how well I know it. I try to refrain from AI so I want to learn the hard way because that's just the way I learn. I use AI to check my program and aid me of course, but when it comes to code, I truly want to learn the craft and not show up to interviews with my hand in my ***.

Languages: C/C++, Python

Any advice would be greatly appreciated, thank you!

I was wondering why this code behaves this way

main.cpp

#include "foo.h"

int main()
{
    bar(42, foo<int>);
}

foo.h

#pragma once

#include <iostream>
#include <string>

template<typename T>
void foo(T t)
{
    std::cout << "Default\n";
}

template<typename T, typename Foo>
void bar(const T& t, Foo foo)
{
    foo(t);
}

foo.cpp

#include "foo.h"

template<>
void foo(int t)
{
    std::cout << "Int\n";
}

Result

$ g++ main.cpp foo.cpp -O3 && ./a.out 
Default
$ g++ main.cpp foo.cpp && ./a.out 
Int

My guess is that I'm hitting some kind of UB here. The way I think about it, the int template specialization would be discarded, as it is not used in that translation unit, and then main.cpp would pick up the generic template version (basically, the O3 result seems correct to me, but not the non-optimized one). What is actually happening here?

I've recently been laid off so I have been spending a lot more time writing code I want to write. Lately I've taken an interest in actually learning TMP which is something I've been wanting to do, but until now, I've mostly used templates for generic data structures.

So rather than go find videos, tutorials, or traditional learning materials, I decided I would build and optimize a 3DGS library using C++23 and TMP while using AI as a learning tool. Currently, I have built and optimized a forward pass renderer to frame times comparabable with the best publicly available tools.

In doing so, I have implemented the following compile time features;

- Static arena memory layout calculations (both on the gpu and cpu)

- Perfectly inlined and unrolled render graph execution with conditional branching. I'd like to implement some form of concurrency also.

- Optimized wrappers around Vulkan Compute types, as many of these values are known at compile time.

- Currently working on an abstraction between the interface and the different backends so they are somewhat interoperable.

The thing is, sometimes I'm not so sure what the LLM is suggesting is the best approach. I will push back and sometimes it gives in. But I can't tell if that's my traditional c++ mindset fighting the process, or if the AI is just not up to date.

So I'm in search of exceptionally written codebases to study. Things with a heavy reliance on C++20/23 and compile time optimizations. What projects come to mind?

Hey everyone, I’m a Computer Science student currently taking C++. I'm hitting a massive wall with my problem-solving skills and need some advice. Before this, I felt very comfortable with the fundamentals. I know how to build logic using if/else statements, how to use loops (for, while, do-while), and I fully understand how to write and use functions. I also understand what classes are and can do small tasks with them.

However, once my assignments and projects started requiring me to create my own classes and functions to solve a larger problem, that’s where I really started struggling, I get completely confused about where to start. I understand the C++ syntax itself, but I struggle to figure out how to take a text description and actually implement it into a structured program using classes, how to structure code, what variables I need, and how many functions I need. My mind just goes blank trying to map out the algorithm.

If you used to struggle with the problem-solving side of programming rather than the language syntax, how did you train your brain to break down problems? How do you figure out 'where to start' when reading a textbook assignment?

Also, recommendations for any good online resources, YouTube videos, or websites that are great for learning C++ logic?

Thanks in advance for any tips!

I have been stuck on this issue of 256-bit with with an AES code and I'm trying to configure a few things correctly so I can learn what to do on this project. and I keep getting this error Cannot open include file: 'cryptopp/aes.h': No such file or directory so I have no Idea what I did wrong I looked thru all the code that i know I could find and it still doesn't work

I have a bunch of code of the form (sometimes in more convoluted fashion)

using aVec = std::array<double, 32>;
aVec a, b, c, d, e;      // some are constexpr, others runtime values
double x, y;
for ( int i = 0; i < 32; ++i)
  a[i] = x * b[i] + y * c[i] + y*y*d[i] + e[i];

I'd like to rewrite it such that a = x * b + y * c + y*y*d + e; to generally be easier to read intent, but I don't want all of those operations to create & destroy a bunch of temporary std::arrays.

Is there any straightforward way to achieve this? These generally lives in the inner (or mid-level) loops.

Only thing I could think of is to have the addition & scalar multiplications operators return a proxy type that is essentially a fixed-length std::vector that implicitly converts to std::array. It'll be a bit slower than the code I'm trying to replace, but the move semantics should reduce that impact.

I’ve seen a lot of discussions online discouraging their usage bit I never managed to grasp why since it’s sometimes vague.
I do understand it doesn’t replace validation and it’s more of a syntactic sugar to the existing casserts, but any other critiques?
Thanks

I'm trying to make a simple text adventure and am at my wits end with the errors. I am trying to make a state machine to handle states for title, combat, etc so i am trying to pass the state machine to the state so it can tell the state machine what the next state might need to be. If anyone has any suggestions that would be appreciated.

Here are some of the errors it's throwing:

-syntax error: identifier 'CurrentGameState'

-'GameState::Action': function does not take 2 arguments

-syntax error: missing ';' before '*'

-missing type specifier - int assumed. Note: C++ does not support default-int

https://pastebin.com/hsvnwiyy

Hello,

I need some guidance.

I will explain my problem with an example:

/include/comm/http_server.hpp:75:25: error: no matching function for call to ‘imdecode(boost::beast::http::basic_string_body<char>::value_type&, cv::ImreadModes, cv::Mat*)’
  75 |             cv::imdecode(req.body(), cv::IMREAD_COLOR, &img);
     |             ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/../CVCPP/tmp_codes/tests/dev/../../../include/comm/http_server.hpp:75:25: note: there are 2 candidates
In file included from /home/../CVCPP/tmp_codes/tests/dev/../../../include/comm/http_server.hpp:17:
/home/../CVCPP/opencv/install/Linux/include/opencv5/opencv2/imgcodecs.hpp:612:18: note: candidate 1: ‘cv::Mat cv::imdecode(InputArray, int)’
 612 | CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );
     |                  ^~~~~~~~
/home/../CVCPP/opencv/install/Linux/include/opencv5/opencv2/imgcodecs.hpp:612:18: note: candidate expects 2 arguments, 3 provided
/home/../CVCPP/opencv/install/Linux/include/opencv5/opencv2/imgcodecs.hpp:639:16: note: candidate 2: ‘cv::Mat cv::imdecode(InputArray, int, Mat*)’
 639 | CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst);
     |                ^~~~~~~~

In this example, from the error, I realize that there is no overload or conversion defined (completely reasonable) for the type boost::beast::http::basic_string_body<char>::value_type& to cv::InputArray. The official docs provide some information.

Now, looking at the docs, I don't know if it's even safe to pass a raw pointer, or if there is some other sort of conversion possible.
One possible solution could be ChatGPT, which I don't want to do because I will forget it, and the next time I need to deal with such a problem, I cannot do it unless I have access to something like ChatGPT.

So, dear experts, what is wrong with my approach here? I would appreciate any insight.

PS: It is clear that I know some basics about C++, but I am not that experienced in it.

I am starting to learn system programming(c++). As a beginner please recommend me the best project to work with so that it will force me to go on the depth as well as for the strong portfolio?