CodeBlock using Specified Collection Tag .Code

VerzatileDev · VerzatileDev · commit d8845e6141c2 · 2024-01-15T17:05:39.000+02:00
Addionally change the way code block titles are being handled and made a specified collection tag specifically for it, it can be used with the .highlight system under code.scss or it can be used separately as a standalone example without using the CodeBlock, with the copy button and a few other features.
diff --git a/docs/Language/C++/Addresses.md b/docs/Language/C++/Addresses.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 In C++, the ampersand (`&`) symbol is the address-of operator, used to obtain the memory address of a variable. The memory address represents the location in the computer's memory where the variable is stored.
 
-{: .example }
+{: .code}
 ```cpp
 int someVar = 69;
 int* somePtr = &someVar; // Pointer now holds the address of someVar
@@ -25,7 +25,7 @@ int value = *somePtr;  // Retrieves the value stored at the memory address
 
 The memory address is typically represented as a hexadecimal number.
 
-{: .example }
+{: .code}
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/C++.md b/docs/Language/C++/C++.md
@@ -95,7 +95,7 @@ Simply create a new C++ source file (typically with a .cpp extension) using your
 
 Here's a simple "Hello, World!" program:
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
@@ -114,7 +114,7 @@ Save your C++ code with a meaningful filename and the .cpp extension.
 
 Use the command-line interface or the IDE to compile your C++ code, using GCC:
 
-{: .example }
+{: .code }
 ```bash
 g++ your_program.cpp -o your_program
 ```
diff --git a/docs/Language/C++/ConstantPointerToConstant.md b/docs/Language/C++/ConstantPointerToConstant.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Constant Pointers To Constants are a C++ pointer type that cannot be used to modify the value it points to, and the pointer itself cannot be reassigned to point to a different memory location. This provides a high level of const-correctness and is often used to indicate that both the pointer and the pointed-to value are constant.
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 const int* const constPointerToConst = &someVar;
@@ -35,7 +35,7 @@ It offers several benefits:
 - When used in function parameters or class member functions, const pointers to const contribute to designing safer interfaces by indicating that the function/method will not modify the input data.
 - Allows the compiler to make certain optimizations based on the const-correctness, potentially leading to more efficient code.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/ConstantPointers.md b/docs/Language/C++/ConstantPointers.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Constant Pointers are quite straightforward - as with any other standard `const` variable in C++, it's a type of pointer that cannot be reassigned to point to a different memory address. It still allows read-write access to the pointed-to variable though!
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 int* const constPointer = &someVar;
@@ -34,7 +34,7 @@ It offers a few benefits:
 - When used in function parameters or class member functions, const pointers contribute to designing safer interfaces by indicating that the function/method will not modify the pointer itself, offering const-correctness.
 - Allows the compiler to make certain optimizations based on const-correctness, potentially leading to more efficient code.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/Dereferencing.md b/docs/Language/C++/Dereferencing.md
@@ -16,14 +16,14 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 The dereference operator (`*`) is used to access the value at the memory address stored in a pointer.
 
-{: .example }
+{: .code }
 ```cpp
 int someValue = *somePtr;  // Retrieves the value stored at the memory address 
 ```
 
 Dereferencing also allows you to modify the value stored at the memory address.
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 420;
 int* somePtr = &someVar;
@@ -32,7 +32,7 @@ int* somePtr = &someVar;
 
 When working with pointers to class members, the `->` operator is often used for dereferencing.
 
-{: .example }
+{: .code }
 ```cpp
 class SomeClass 
 {
@@ -47,7 +47,7 @@ ptr->someData = 69;  // Dereferencing using the -> operator to access class memb
 
 Dereferencing is often combined with pointer arithmetic to manipulate arrays, flags, or other blocks of data.
 
-{: .example }
+{: .code }
 ```cpp
 int main() 
 {
diff --git a/docs/Language/C++/MemberPointers.md b/docs/Language/C++/MemberPointers.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Member Pointers are traditional pointers that point to class or struct members.
 
-{: .example }
+{: .code }
 ```cpp
 class SomeClass 
 {
diff --git a/docs/Language/C++/MultilevelPointers.md b/docs/Language/C++/MultilevelPointers.md
@@ -24,15 +24,15 @@ While these types of pointers provide flexibility, they can make code more error
 
 A regular pointer is a single-level pointer, pointing directly to a variable.
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 int* singlePointer = &someVar;  // Single-level pointer
 ```
 
 A double-pointer stores the address of another pointer.
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 int* singlePointer = &someVar;
@@ -41,7 +41,7 @@ int** doublePointer = &singlePointer;  // Double-level pointer
 
 A triple-pointer is a pointer that stores the address of a double-pointer.
 
-{: .example }
+{: .code }
 ```cpp
 int myValue = 69;
 int* singlePointer = &someVar;
@@ -51,7 +51,7 @@ int*** triplePointer = &doublePointer;  // Triple-level pointer
 
 Each level of indirection requires an additional dereference to access the actual value that is being pointed to by the pointer "below" it.
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 int* singlePointer = &someVar;
@@ -63,7 +63,7 @@ int value = ***triplePointer;  // Accesses the value (69) through triple indirec
 
 Multilevel pointers are commonly used in dynamic memory allocation scenarios.
 
-{: .example }
+{: .code }
 ```cpp
 int*** MakeTriplePointer() 
 {
@@ -100,7 +100,7 @@ Multilevel pointers are also useful for handling arrays of pointers or for guard
 > "There are readability concerns for sure. As for it being a guard, _kind of, I guess?_ The main issue is that the API's are templated, so it is already kind of expecting to return a `float*` or `int*` or whatever, which, in my opinion is totally legit  - guarding, like you said. But, if the array is an array of points to BEGIN with, you're left with the `**` nonsense."  
 > _- [@Tom Shinton](www.tomshinton.com), Discussion about Multilevel Pointer use-cases._
 
-{: .example }
+{: .code }
 ```cpp 
 #include <iostream>
 
diff --git a/docs/Language/C++/NullPointers.md b/docs/Language/C++/NullPointers.md
@@ -18,7 +18,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Initializing a pointer without assigning it a specific address sets it to a null pointer.
 
-{: .example }
+{: .code }
 ```cpp
 int* nullPointer = nullptr;
 ```
@@ -27,7 +27,7 @@ Note that a `nullptr` is not implicitly convertible to integral types, which hel
 
 Checking or Guarding for invalid pointers frequently in your code is good practice, especially when writing critical programs.
 
-{: .example }
+{: .code }
 ```cpp
 class SomeClass 
 {
diff --git a/docs/Language/C++/PointerToConstant.md b/docs/Language/C++/PointerToConstant.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Pointers To Constants in C++ are pointers that can have their memory address reassigned, but cannot be used to modify the value they point to (just like a standard `const` variable). The target is flexible, but the pointed-to value cannot be modified!
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 const int* pointerToConst = &someVar;
@@ -33,7 +33,7 @@ It offers a few benefits:
 - When used in function parameters or class member functions, a pointer to const indicates that the function/method will not modify the input data, offering safer interfaces.
 - Allows the compiler to make certain optimizations based on const-correctness, potentially leading to more efficient code.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/Pointers.md b/docs/Language/C++/Pointers.md
@@ -20,7 +20,7 @@ In C++, pointers are variables that store references to memory addresses of othe
 
 Imagine that pointers are like "signposts" that tell you where an object is in a box, rather than being a copy of the object - when there are several thousand objects floating around, the advantages are clear and can help to ensure operations occur on the correct object reference!
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/RawPointers.md b/docs/Language/C++/RawPointers.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Raw pointers (`*`) are pointers that directly store the memory address of another variable. They are considered "raw" because they provide a direct and unmanaged interface to memory.
 
-{: .example }
+{: .code }
 ```cpp
 int* somePtr;  // Declaration of an integer pointer
 ```
@@ -25,7 +25,7 @@ Simple and straightforward to use, they directly represent memory addresses, mak
 
 When interacting with C libraries or other languages that don't have the concept of smart pointers, they are also the most compatible option.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/References.md b/docs/Language/C++/References.md
@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 While not a pointer type, references are often used in C++ as an alternative to pointers for providing an alias to an existing variable (a way to access that variable through a different name). They must be initialized when declared and cannot be reassigned.
 
-{: .example }
+{: .code }
 ```cpp
 int someVar = 69;
 int& someReference = someVar;
@@ -32,7 +32,7 @@ References offer some benefits, such as:
 - References improve code readability by creating expressive and self-documenting code. The use of references indicates that the variable is being referenced or modified within a function.
 - References are commonly used in operator overloading, allowing you to define custom behaviors for operators like +, -, etc.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
diff --git a/docs/Language/C++/SmartPointers.md b/docs/Language/C++/SmartPointers.md
@@ -29,7 +29,7 @@ Unique pointers (`std::unique_ptr`) represent exclusive ownership of a dynamical
 
 Unique pointers enforces exclusive ownership, preventing multiple pointers from managing the same resource simultaneously.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 #include <memory>
@@ -70,7 +70,7 @@ int main()
 
 Shared pointers (`std::shared_ptr`) enable shared ownership of a dynamically allocated object. It uses a reference counting mechanism, and the memory is deallocated only when the last shared pointer releases its ownership. It's useful for scenarios where multiple pointers need to share access to the same dynamically allocated object.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 #include <memory>
diff --git a/docs/Language/C++/VoidPointers.md b/docs/Language/C++/VoidPointers.md
@@ -16,14 +16,14 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b
 
 Void pointers `(void*)` are a special type of pointer that can point to objects of any data type. The `void` keyword is used as a placeholder for any data type - it behaves a bit like a templated type (like `T`). Void pointers can be assigned the address of any object.
 
-{: .example }
+{: .code }
 ```cpp
 void* genericPointer;
 ```
 
 Of course, void pointers are not type-safe, meaning they do not have information about the type of data they point to. It's the programmer's responsibility to ensure proper casting when using void pointers.
 
-{: .example }
+{: .code }
 ```cpp
 int integerValue = 69;
 float floatValue = 4.20;
@@ -37,7 +37,7 @@ voidPointer = &floatValue;    // Address of a float
 Void pointers can point to different types during their lifetimes.
 To use the value pointed to by a void pointer, you need to cast it to the appropriate type.
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 
@@ -59,22 +59,22 @@ int main()
 
 Void pointers are often used in dynamic memory allocation functions (`malloc`, `calloc`, `realloc`), which return a void pointer to the allocated memory block.
 
-{: .example }
+{: .code }
 ```cpp
 void* someDynamicMemory = malloc(sizeof(int));
 ```
 
 Void pointers are usually used in functions that need to operate on data of unknown types, where we can't know what could be getting passed around at runtime.
 
-{: .example }
+{: .code }
 ```cpp
 void genericFunction(void* data, size_t size);
 ```
 
 Void pointers do not provide type information, so improper casting can lead to runtime errors. It's essential to use them carefully and only when necessary, as they may make the code less readable and harder to maintain. In my example below, the type of void pointer is changed from an integer to a float, and even in this simple situation it can get quite difficult to follow.
 
 
-{: .example }
+{: .code }
 ```cpp
 #include <iostream>
 

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ If not, please refer to the [C++](/docs/Language/C++/C++.html) section of this b`
`16`	`16`
`17`	`17`	`Member Pointers are traditional pointers that point to class or struct members.`
`18`	`18`
`19`		`-{: .example }`
	`19`	`+{: .code }`
`20`	`20`	```cpp
`21`	`21`	`class SomeClass`
`22`	`22`	`{`