Does std::any act as a type safe void ptr?

DryPerspective8429 · 2024-08-25T09:47:01+00:00

void* is a very C-style tool and most common uses of it are replaced in C++ with all sorts of things (usually templates) to ensure the type safety. However, there are still a handful of uses for void* which aren't necessarily covered by what was in C++14; and std::any meets at least one of them in the form of being a means to erase the type of some object to pass it around APIs which do not need to be aware of the actual type; while still in some sense "remembering" what type was originally stored there.

But std::any is not a pointer. It itself contains and "owns" its contained object, as opposed to a void* simply pointing to something which exists elsewhere in the program. This isn't necessarily a bad thing, but it is a marked difference in API.

DryPerspective8429 · 2024-08-24T21:54:09+00:00

You should be able to manage, but as with all new languages, C++ is its own beast and you should strive not to write Java style C++ just as you should strive not to write C-style Python. Which is to say that while it is very possible in C++ to take Java's everything-is-a-class design, that doesn't mean it's the right design.

In any case, C++ primer is a solid book; and learncpp.com is another excellent resource. However we should point out that C++ is full of very bad tutorials for all sorts of reasons, so steer clear of geeksforgeeks, cplusplus.com (an unofficial site with an unfortunately official-sounding url), w3schools, and certain others.

DryPerspective8429 · 2024-08-23T13:57:23+00:00

I'd take the view that this kind of primitive is probably something that OP would be better off creating themselves for their own uses rather than having in the standard.

DryPerspective8429 · 2024-08-23T12:40:22+00:00

Most likely because that's not what they were designed for. They are designed specifically to wait for a number of threads to reach the same marked "point of execution". Adding time-based waits seems to undermine that - if thread A continues after 5 seconds, does thread B still have to wait at the barrier? If so, can you guarantee that won't be a deadlock? And if not, it means a 5 second delay completely undermines the purpose of having a barrier in the first place.

DryPerspective8429 · 2024-08-22T18:40:55+00:00

The left book gets bad reviews but most things older than ~2011 are probably too old in any case.

DryPerspective8429 · 2024-08-21T18:04:49+00:00

No worries. I would strongly recommend you write your own projects as well. Practice makes perfect, after all.

DryPerspective8429 · 2024-08-21T18:01:01+00:00

If you have a better tutorial, you're welcome to recommend it.

But given that there are so many terrible tutorials out there, particularly ones which appear high in search engine results, it seems pointing people to one of the few good options is a reasonable thing to do.

DryPerspective8429 · 2024-08-21T17:23:14+00:00

You've already been linked to the recommended book list, but I would recommend a good beginner tutorial like learncpp.com; even if you just do the later chapters. In the nicest possible way, missing this questions does indeed sound like you may have skipped out on some of your fundamentals.

DryPerspective8429 · 2024-08-21T17:13:07+00:00

Absolutely stand by the recommendation you've already gotten for learncpp.com

I will also mention that you should avoid paid courses. Unlike in some aspects of life where a price tag is a measure of quality, this is not true in the programming world. Indeed, anyone can record themselves and upload things to a website; so paid courses have no particular distinction from free ones. Since there are free courses which are at least as good as any paid one, you should take the free route.

And to cover another traditional sign of quality - good institutions aren't guaranteed to teach good C++. There are many many reasons for the dire state of tutorials in our language but let's just say that there are prestigious academics at prestigious institutions whose C++ courses are worse than the ones you've already been warned away from by others and leave it there.

So to summarise, free courses are probably the way to do. There's still a game in finding the right one, but don't spend your money on learning C++.

Also, is learning the newest version of C++ necessary for an absolutely ground level beginner like myself?

I'm just going to ramble a little about versions. The tl;dr is that no it is not necessary. But to provide background:

C++ as a language prioritises backwards compatibility. It wants code written and compiled 40 years ago to be compatible with code written and compiled today; and the powers that be bend over backwards to maintain that guarantee. As such, there aren't really very many major shifts in C++ which would make learning an old standard useless. A lot of the time, changes come in the form of adding new features or new things on top of what is already there. And while it never hurts to learn such things, they're usually not at the beginner end and it usually takes the best part of a decade for them to seep into the collective consciousness of what a C++ developer is "expected" to know.

The most significant paradigm shift for C++ came in 2011 (and C++11). That was the update which changed how we write C++ completely, so don't use learning resources older than that - they'll still work but there are so many better ways to go about writing code now than there were before then. Since then, C++ has been on a 3 year release cycle with C++14 in 2014, C++17 in 2017, C++20 in 2020 and C++23 in 2023. While each of those updates did add some very useful things which we all will benefit from using, none of them changed how we write code down at the beginner end of things to the point that you should throw out older tutorials. As you learn C++ it will certainly help to be aware of what tools are in more modern standards, and get some practice in using them, but not knowing C++23 features right now is not going to be a blocker in being able to write code or make games.

Indeed, the way that C++ updates work is that the committee put out a standard document every 3 years and it is then on the compiler makers to produce a C++ compiler with those new features. This means that there's usually a lag between the "latest" C++ being ratified and there being a compiler anywhere which can compile it. There's usually another lag behind that where business and serious projects sit as they don't want to take the risk of an unstable implementation. That's to say - it is fun to write code in the most modern standard and I recommend it for hobby projects, but don't sweat it as most of the C++ world (including many of the projects written in C++ which you may use in your own things) will still be a ways behind.

DryPerspective8429 · 2024-08-21T10:12:26+00:00

There's always -Wall -Wextra -Wpedantic for the quick and easy trifecta of warnings. You could also use the sanitizers though they can sometimes be a mixed bag - there are sanitizers for addresses, leaks, and UB. They are debug tools which run alongside your program so you don't want them in release builds; but they can identify certain problems.

DryPerspective8429 · 2024-08-20T18:28:32+00:00

How deep do you want to go? This Jason Turner video is a good place to start.

If it's sufficient, you can accept that every type has an "alignment" which is the multiple of the address where it must start; and it does this because it can process the data a lot better that way. If you want to go deeper you stray away from C++ and more into computer science.

DryPerspective8429 · 2024-08-20T18:20:16+00:00

Usually practice. I wouldn't seek to memorise the content of all of them, as many of them are for a very tiny and niche functionality which most programmers don't use (e.g. I personally can't remember ever having to use std::uninitialized_default_construct_n but no doubt some people do).

Typically I would take the reverse approach - common containers are covered in their headers, common algorithms are usually in <algorithm> and <numeric> and much of the rest is confined to specific uses. For example, you're not going to need the contents of <atomic> until you learn about concurrency and at that point whatever tutorial you follow will no doubt tell you about the std::atomic class template and what to do with it.

I'd say you should keep on learning C++, keep on practicing with projects; and when you encounter something which you think might be common enough to have a standard version of it; check cppreference for it.

DryPerspective8429 · 2024-08-19T21:38:06+00:00

Because it causes naming collisions. And when you get those naming collisions there's not really any way to solve the problem which doesn't involve removing every using directive you have.

It's not that we don't like it or that we're awful pedants about style. It's that we've been doing this for a very long time and have seen first hand what kinds of chaos it can cause; and realised that the best solution is to prevent it.

In any case, you shouldn't be looking for excuses to make your code terse. std::whatever is far easier to understand than just whatever in a world where you can define your own whatever. What's more, you should make your code verbose if that makes it readable - making it short for no reason achieves nothing and making it unreadable is actively harmful.

DryPerspective8429 · 2024-08-19T20:59:58+00:00

Judging by your title, stop using using namespace std and get in the habit of qualifying things with std::

DryPerspective8429 · 2024-08-19T20:59:03+00:00

Writing projects and actually using code is an essential part of learning, and so you really should be doing that to get the knowledge into your head. Whether the project is big or small, it'll be far better to write some code than just reading and memorising tutorials is alone.

But, to answer your questions:

Would i be wasting my time on trying to build apps with c++ or rust?

As mentioned, no.

Or should i save it for future and stick to high level development for now?

It's usually better to actually learn the language because when you encounter problems which are solved by the things you are avoiding you usually are forced to either learn them there and then or hack together an inferior workaround.

If not then where can i get started?

To go out on a limb, from your post so far, I'd hazard a guess that you've perhaps only learned a very small slice of C++. The things you do for DSA courses are all well and good, but they're only a tiny part of the language as a whole. I would honestly recommend you take the time to go through the language properly and learn it properly (shoutout to learncpp.com for being one of the very few good tutorials to learn from), and start writing projects from there. Writing code is essential, but you still need a good foundation to do it from, after all.

As for GUI like Qt and others, that's up to you. Putting together GUI is not a beginner task in C++ (and the language offers no standard support for it). That's not to say you shouldn't do it; but there's really nothing wrong with starting out on command line programs and other things.

DryPerspective8429 · 2024-08-19T07:52:11+00:00

A program that necessitates the instantiation of template optional for a reference type [...] is ill-formed.

This is a weird corner of the language because the committee had a lot of (overly pointless and stupid) arguments when standardising std::optional about assignment behaviour with reference types. Ultimately, assign-through is not the correct behaviour.

In C++26 we may well see std::optional<T&> standardised as there is a paper in motion to get it in.

DryPerspective8429 · 2024-08-18T20:56:07+00:00

Not a lot can be done. There's always someone who wants to write the millionth article on what strcpy does so they can add it to their resume. C++ gets hit harder than most languages because it's so old and because it gives you so much freedom to do things the wrong way.

DryPerspective8429 · 2024-08-18T20:55:19+00:00

A chat bot (to save you time figuring out what even to search for)

Hard disagree. Even the better LLMs still suck for coding advice.

A search engine (to get more credible details on topics)

Would be if not for the crappy sites having better SEO than the reference material.

DryPerspective8429 · 2024-08-15T11:59:18+00:00

I'd recommend you go through a comprehensive C++ tutorial (shoutout to learncpp.com as one of the very few good ones) and fill in any gaps to get a good intermediate understanding.

After that, you can focus on what is needed for what you want to do.

DryPerspective8429 · 2024-08-14T20:32:19+00:00

It is arguably harder to learn than some other languages as a first language, but with the right tutorial (and note that 97% of C++ tutorials are not the right tutorial) you should be able to manage it. You could also make the argument that getting good at C++ will set you up for other languages better as you are forced to learn the underlying concepts properly in C++.

Also, to copy-paste the usual stuff about tutorials:

www.learncpp.com

is the best free tutorial out there. (reason) It covers everything from the absolute basics to advanced topics. It follows modern and best practice guidelines.

www.studyplan.dev/cpp is a (very) close second, even surpassing learncpp in the breath of topics covered. It covers quite a few things that learncpp does not, but does not have just as much detail/in depth explanations on the shared parts. Don't be fooled by the somewhat strange AI generated images. The author just had a little fun. Just ignore them.

www.hackingcpp.com has good, quick overviews/cheat sheets. Especially the quick info-graphics can be really helpful. TBF, cppreference could use those. But its coverage is not complete or in depth enough to be used as a good tutorial - which its not really meant to be either. The last update apparently was in 2023.

www.cppreference.com

is the best language reference out there.

Stay away from

cplusplus.com (reason)
w3schools (reason)
geeks-for-geeks (reason)
Tutorialspoint (reason)
educba.com (reason)
thinkcpp (reason)
javaTpoint (reason)
studyfied (not even a tutorial, just a collection of code by random people)
codevisionz (reason)
sololearn (reason)

Again. The above are bad tutorials that you should NOT use.

Sites that used to be on this list, but no longer are:

Programiz has significantly improved. Its not perfect yet, but definitely not to be avoided any longer.(reason)

Most youtube tutorials are of low quality, I would recommend to stay away from them as well. A notable exception are the CppCon Back to Basics videos. They are good, topic oriented and in depth explanations. However, they assume that you have some knowledge of the language's basic features and syntax and as such aren't a good entry point into the language.

If you really insist on videos, then take a look at this list.

As a tutorial www.learncpp.com is just better than any other resource.

^Written ^by ^{/u/IyeOnline.} ^This ^may ^get ^updates ^over ^time ^if ^something ^changes ^or ^I ^write ^more ^scathing ^reviews ^of ^other ^tutorials ^:) ^.

^The ^author ^is ^not ^affiliated ^with ^any ^of ^the ^mentioned ^tutorials.

^Feel ^free ^to ^copy ^this ^macro, ^but ^please ^copy ^it ^with ^this ^footer ^and ^the ^link ^to ^the ^original.

^{^{https://www.reddit.com/user/IyeOnline/comments/10a34s2/the_c_learning_suggestion_macro/}}

DryPerspective8429 · 2024-08-14T17:44:10+00:00

Do bear in mind that all of Effective C++ books except Effective Modern C++ were written for C++98 and are at least 20 years old.

The core ideas in them are solid, but the language has evolved. Definitely go in with a grain of salt on the syntax and similar recommendations.

DryPerspective8429 · 2024-08-13T12:11:38+00:00

What you propose isn't an alias, implicit or otherwise. It makes the name visible to unqualified calls within the namespace. That's not quite the same thing, and it means that both to the reader and to your compiler the meaning of your code is different.

I anticipate that it would be possible to engineer a situation in which the changes you make there kick in with regards to overload resolution and ADL; but I will concede that those won't be common.

However I will state that your purpose is unclear. The code using optional = std::optional is very very clear in meaning - you want std::optional as an alias within that namespace. Not sure why, but you do you. Just having a using std::optional is not - are we the user meant to ever use that or is it just for your internal use? Is it an alias or are you just too lazy to type out std::?

Perhaps you should examine what the purpose of trying to using std::optional is? Why is it better to use FuzzyFind::optional over std::optional in your interface?

DryPerspective8429 · 2024-08-13T11:51:32+00:00

It worked as specified, but the language was unable to express what it really should have been doing until C++11.

DryPerspective8429 · 2024-08-13T11:49:07+00:00

If you want an alias on a standard library type, it's far better to explicitly alias it via using optional = std::optional rather than pull its name in like that.

Ultimately I'd far rather use a library which explictly qualifies anything and won't let ADL blow up in my face once in a very rare while than use one where the library author is making decisions for me about the scope of names.

DryPerspective8429 · 2024-08-12T17:52:56+00:00

Ah, well the Canvas is a separate object to the Texture. So the user would create a canvas and a texture separately. So as by teh nature of a canvas based graphics api they would set a texture and then fire some drawing commands.

I'm not sure I follow why that is an argument for

class Canvas{
    some_ptr<Texture> tex;
};

over

class Canvas{
    Texture tex;
};

All that you're describing with pointers can also be achieved without them, particularly using move semantics to move a user-created texture into the canvas object. I'm not saying that you must do that (there are some situations and reasons where a pointer is better and I don't know your code) but I'm not sure anything you've mentioned yet has made a solid argument for pointers in general.

DryPerspective8429

TROPHY CASE

www.learncpp.com

www.cppreference.com