In this blog post, we’ll explore how std::erase functions simplify container manipulation and improve code readability.

Dealing with the removal of specific elements from a container in your C++ code can often be a cumbersome and error-prone task. Fortunately, C++20 introduces two powerful allies to streamline this process: std::erase and std::erase_if. These functions bring efficiency and clarity to element removal, and in this article, we’ll explore their workings and benefits.

Why We Need Easy Element Removal

When you’re working with C++ containers like vectors or lists, you often want to kick out some elements based on certain conditions or values. Before C++20, this was like navigating a maze blindfolded. You had to write loops and custom code to find and remove the elements you wanted. Not exactly a picnic, right?

Meet std::erase: The Element Eraser

std::erase is like the Marie Kondo of C++20. It helps you tidy up your container by removing all instances of a specific value. It’s super easy to use and works with various container types—vectors, lists, and even sets and maps. Here’s how it works:

cppCopy code

std::vector<int> numbers = {1, 2, 3, 2, 4, 2, 5}; std::erase(numbers, 2);  // Say goodbye to all those 2s

In this example, we’re saying, “Hey, std::erase, please get rid of all the 2s.” And just like magic, the vector becomes {1, 3, 4, 5}. Neat, right?

Meet std::erase_if: The Selective Element Picker

Now, what if you want to get a bit pickier and remove elements based on custom conditions? That’s where std::erase_if comes in. It’s like having a personal assistant that follows your criteria. Check it out:

cppCopy code

std::vector<int> numbers = {1, 2, 3, 4, 5, 6}; std::erase_if(numbers, [](int n) { returnn % 2 == 0; });  // Adios, even numbers!

In this case, we’re using a cool lambda function as a “picker.” It says, “Bye-bye, even numbers,” and, voilà, we’re left with {1, 3, 5}. std::erase_if lets you customize the removal process based on your whims and fancies.

The Perks of std::erase and std::erase_if

These new additions in C++20 bring some serious perks:

1. Readability: Your code becomes a breeze to read because these functions spell out your intent—removing elements—right in their names.
2. Simplicity: One function call does the trick, no more convoluted loops or DIY removal code.
3. Safety: Standard library functions are your trusty sidekicks, reducing the risk of bugs and odd edge cases in your element removal logic.
4. Performance: These functions are turbocharged for efficiency, so your code stays zippy even when you’re juggling large containers.

In Conclusion

Say goodbye to the headaches of element removal and embrace the simplicity of std::erase and std::erase_if. They make your code cleaner, more readable, and safer. Whether you’re cleaning up by value or on your custom criteria, C++20 has your back. So go ahead, give these new features a whirl in your C++ projects, and let your code shine. Happy coding! 🚀👨‍💻

The C++ –> is used for … well. I came across this post on Stackoverflow where someone asks what the –> operator in C++ is for, with the following code snippet:

while (x --> 0)
{
    printf("%d ", x);
}

I asked ChatGPT what the –> operator is, and it correctly stated that it “appears to use a non-standard and unconventional usage of the --> operator, which is not a standard operator in C++.” – which is quite good considering the hallucination it often shows. Furthermore, it says:

In C++, the --> operator doesn’t have any predefined meaning or behavior. Instead, it appears that the code you’ve shown is trying to use the -- (decrement) operator followed by the > (greater than) operator. However, this is not valid C++ syntax.

This is pretty much in line with the answer of the post on Stack Overflow.

Just for the fun, I asked ChatGPT how an implementation would look like if it was a valid operator, and this is what it came up with:

#include <iostream>

class CustomClass {
private:
    int value;

public:
    CustomClass(int val) : value(val) {}

    // Overloading the -->(...) operator
    CustomClass operator-->(int incrementValue) {
        CustomClass temp(*this);
        value += incrementValue;
        return temp;
    }

    int getValue() const {
        return value;
    }
};

int main() {
    CustomClass obj(5);

    // Using the custom -->(...) operator
    obj = obj-->(3);

    std::cout << "Value after custom operation: " << obj.getValue() << std::endl;

    return 0;
}

Now I asked it if it could imagine what the –> operator could be used for. Here is the answer:

Let’s imagine a use case for the --> operator in a hypothetical scenario:

Suppose you are working on a complex numerical simulation or mathematical modeling library in C++. In such a library, you might frequently work with mathematical expressions and matrices. You could use the --> operator as a custom operator for matrix operations, specifically for updating matrix elements in a concise and intuitive way.

It also mentions I should keep in mind that this is entirely speculative, as the --> operator doesn’t exist in the C++ language, and inventing custom operators should be done judiciously and with care for code readability and maintainability.

Then it produced some code:

#include <iostream>
#include <vector>

class Matrix {
private:
    std::vector<std::vector<double>> data;

public:
    Matrix(const std::vector<std::vector<double>>& input) : data(input) {}

    // Overload the --> operator for element updates
    double& operator-->(const std::pair<int, int>& indices) {
        int row = indices.first;
        int col = indices.second;

        if (row >= 0 && row < data.size() && col >= 0 && col < data[0].size()) {
            return data[row][col];
        } else {
            throw std::out_of_range("Matrix element out of bounds");
        }
    }

    // Display matrix
    void display() const {
        for (const auto& row : data) {
            for (const double& value : row) {
                std::cout << value << ' ';
            }
            std::cout << '\n';
        }
    }
};

int main() {
    std::vector<std::vector<double>> initialData = {{1.0, 2.0}, {3.0, 4.0}};
    Matrix mat(initialData);

    // Use the custom --> operator to update matrix elements
    mat --> std::make_pair(0, 1) = 5.0;

    // Display the updated matrix
    mat.display();

    return 0;
}

• The --> operator is overloaded for the Matrix class to update individual elements of the matrix.
• The operator takes a pair of indices (row and column) and returns a reference to the corresponding matrix element.
• It performs bounds checking to ensure that the indices are within the matrix dimensions.

Well, if C++ had a --> operator, we’d probably have debates about whether it should be called the “rocket ship operator” or the “arrow arrow operator.” And we’d have t-shirts with clever slogans like “I put the ‘fun’ in ‘function'” for C++ developers who love their custom operators. But for now, let’s stick with the good ol’ . and -> and leave the hypothetical operators to our wildest coding dreams! 😄

C++ Modules are a way to organize and manage code in large C++ projects.

Imagine you have a big project with many files and libraries, and each file depends on other files and libraries. Currently, in C++, to use a piece of code from another file, you have to include a header file with declarations, which can result in slow build times and difficult-to-manage dependencies.

C++ Modules aim to solve this problem by allowing you to package up all the code from a library into a single “module” file. You can then import this module into your own code, and you’ll have access to all the code in the module without having to include individual header files. This leads to faster build times and easier-to-manage dependencies.

Think of modules as containers for your code that make it easier to reuse and share with others, without having to worry about the details of how the code is organized or which files depend on which other files.

std::expected is a type defined in the C++23 standard library as a way of handling errors in C++. It is used to represent the result of an operation that may either produce a value or an error. It provides a way to handle expected results in a type-safe and exception-free manner.

The std::expected template has two template parameters: the first is the type of the value that the operation may produce, and the second is the type of the error that the operation may return. The std::expected object can be in one of two states: a valid state, in which it holds a value, or an invalid state, in which it holds an error.

You can use the std::expected object just like a regular value, with the advantage that you can also check if the operation was successful or not. You can use the value() member function to access the stored value, or the error() member function to access the stored error. If the std::expected object is in the invalid state and you try to access the value, a compile-time error will occur.

Here is an example of using std::expected:

#include <iostream>
#include <expected>
#include <string>

std::expected<std::string, std::string> get_greeting(bool happy)
{
    if (happy) {
        return std::string("Hello, friend!");
    } else {
        return std::make_unexpected(std::string("Oh no, something went wrong."));
    }
}

int main()
{
    auto greeting = get_greeting(true);
    if (greeting) {
        std::cout << *greeting << std::endl;
    } else {
        std::cout << greeting.error() << std::endl;
    }
    return 0;
}

In this example, the get_greeting function returns a std::expected<std::string, std::string> object. If the happy argument is true, the function returns a string with a friendly greeting. If happy is false, the function returns an error message using std::make_unexpected.

In the main function, the code checks the state of the std::expected object. If the std::expected object is in the valid state, it contains the greeting and the code outputs the greeting to the console. If the std::expected object is in the invalid state, it contains the error message and the code outputs the error message to the console.

This example demonstrates how std::expected provides a way to handle expected results in a type-safe and exception-free manner, allowing you to check for success or failure and respond accordingly.

Why exception free

std::expected is exception-free because it doesn’t use exceptions to signal error conditions. Instead, it uses a return value to indicate success or failure, which can be checked using the valid() member function or by casting the std::expected object to a bool.

The advantage of using std::expected over exceptions is that it provides a clear and predictable way to handle error conditions. With exceptions, it can be difficult to know exactly where an exception will be thrown, making it harder to write robust and maintainable code. With std::expected, you can see from the function signature what type of error the function might return, and you can handle the error directly in the code that calls the function. This makes it easier to reason about the behavior of your code and to avoid unintended side effects.

In addition, using std::expected can also be more efficient than using exceptions because it avoids the overhead of constructing and unwinding the stack for each exception. This can make your code faster and more scalable, especially in resource-constrained environments where performance is critical.

This is an update to an earlier article where I explained std::expected before it was introduced to the C++23 standard library.