cpp

Anonymous (anonymous@undisclosed.example.com) — 2024-10-12T17:44:07+00:00

C++

It's just like C except we can do more modern things with it. Also the newer versions of the language look like complete gibberish, avoid at all costs.

Casts

Casting in C++ can be quite confusing given the amount of possible ways to cast something. This StackOverflow answer should contain all the information we need, although its contents as of 2024-10-12 have been replicated here:

static_cast

static_cast is the first cast you should attempt to use. It does things like implicit conversions between types (such as int to float, or pointer to void*), and it can also call explicit conversion functions (or implicit ones). In many cases, explicitly stating static_cast isn't necessary, but it's important to note that the T(something) syntax is equivalent to (T)something and should be avoided (more on that later). A T(something, something_else) is safe, however, and guaranteed to call the constructor.

static_cast can also cast through inheritance hierarchies. It is unnecessary when casting upwards (towards a base class), but when casting downwards it can be used as long as it doesn't cast through virtual inheritance. It does not do checking, however, and it is undefined behavior to static_cast down a hierarchy to a type that isn't actually the type of the object.

const_cast

const_cast can be used to remove or add const to a variable; no other C++ cast is capable of removing it (not even reinterpret_cast). It is important to note that modifying a formerly const value is only undefined if the original variable is const; if you use it to take the const off a reference to something that wasn't declared with const, it is safe. This can be useful when overloading member functions based on const, for instance. It can also be used to add const to an object, such as to call a member function overload.

const_cast also works similarly on volatile, though that's less common.

dynamic_cast

dynamic_cast is exclusively used for handling polymorphism. You can cast a pointer or reference to any polymorphic type to any other class type (a polymorphic type has at least one virtual function, declared or inherited). You can use it for more than just casting downwards – you can cast sideways or even up another chain. The dynamic_cast will seek out the desired object and return it if possible. If it can't, it will return nullptr in the case of a pointer, or throw std::bad_cast in the case of a reference.

dynamic_cast has some limitations, though. It doesn't work if there are multiple objects of the same type in the inheritance hierarchy (the so-called 'dreaded diamond') and you aren't using virtual inheritance. It also can only go through public inheritance - it will always fail to travel through protected or private inheritance. This is rarely an issue, however, as such forms of inheritance are rare.

reinterpret_cast

reinterpret_cast is the most dangerous cast, and should be used very sparingly. It turns one type directly into another — such as casting the value from one pointer to another, or storing a pointer in an int, or all sorts of other nasty things. Largely, the only guarantee you get with reinterpret_cast is that normally if you cast the result back to the original type, you will get the exact same value (but *not* if the intermediate type is smaller than the original type). There are a number of conversions that reinterpret_cast cannot do, too. It's often abused for particularly weird conversions and bit manipulations, like turning a raw data stream into actual data, or storing data in the low bits of a pointer to aligned data. For those cases, see std::bit_cast.

C-style cast and function-style cast

C-style cast and function-style cast are casts using (type)object or type(object), respectively, and are functionally equivalent. They are defined as the first of the following which succeeds:

const_cast
static_cast (though ignoring access restrictions)
static_cast (see above), then const_cast
reinterpret_cast
reinterpret_cast, then const_cast

It can therefore be used as a replacement for other casts in some instances, but can be extremely dangerous because of the ability to devolve into a reinterpret_cast, and the latter should be preferred when explicit casting is needed, unless you are sure static_cast will succeed or reinterpret_cast will fail. Even then, consider the longer, more explicit option.

C-style casts also ignore access control when performing a static_cast, which means that they have the ability to perform an operation that no other cast can. This is mostly a kludge, though, and in my mind is just another reason to avoid C-style casts.

std::bit_cast [C++20]

std::bit_cast copies the bits and bytes of the source object (its representation) directly into a new object of the target type. It's a standards-compliant way to do type punning. If you find yourself writing *reinterpret_cast<SomeType*>(&x), you probably should use std::bit_cast<SomeType>(x) instead.

std::bit_cast is declared in <bit>. The objects must be the same size and be trivially copyable. If you can't yet use C++20, use memcpy to copy the source value into a variable of the desired type.

python

Anonymous (anonymous@undisclosed.example.com) — 2023-05-08T07:27:58+00:00

Python

The language of the snake! Known to be, according to the TIOBE Index, the most popular programming language ^{at least in 2023}, used by countless beginner and senior developers throughout the world to create hello world applications and super complex, highly accurate, mind-blowing machine learning and artificial intelligence models, all of this with its horrible whitespace-based syntax and awful looking docblocks.

Even though it has a lot going for it and against it, it is the most popular language, and knowing/using it gives us a great advantage in terms of collaboration and code reuse. Given its size, it's to be expected that they might already have a library for that application that you need to build, or if you thought of something novel and want to build a library for it, most likely if you publish it you are guaranteed get many downloads and maybe even some contributions.

Project Structure

One of the most important aspects of any language is its project structure. If you are building simple one-of scripts hacked together quickly just to perform a task none of this is needed, but as soon as you want to build something that might get used by others or that you might want to publish later in a package manager you need to use the language's proper structure for that. Here are some resources on the topic:

Nathan's KB - lang

cpp

C++