mirror of
https://github.com/mfocko/blog.git
synced 2024-11-12 17:20:30 +01:00
feat(cpp): add placeholders
Signed-off-by: Matej Focko <mfocko@redhat.com>
This commit is contained in:
parent
2ff21c708c
commit
311ebacf84
4 changed files with 293 additions and 0 deletions
205
cpp/07-exceptions-and-raii/2023-11-24-placeholders.md
Normal file
205
cpp/07-exceptions-and-raii/2023-11-24-placeholders.md
Normal file
|
@ -0,0 +1,205 @@
|
|||
---
|
||||
slug: placeholders
|
||||
title: Placeholders
|
||||
description: |
|
||||
Placeholders that are quite convenient to use when working on the code.
|
||||
last_update:
|
||||
date: 2023-11-24
|
||||
---
|
||||
|
||||
Here we will try to implement some placeholders that you can find in other
|
||||
languages, but I miss them in the C++. I'm taking the inspiration from languages
|
||||
like Rust (all that we will implement) or Kotlin (`TODO`) that have them
|
||||
implemented.
|
||||
|
||||
You may ask what placeholders do we need in the code, in our case we will be
|
||||
talking about TODOs and unexpected situations, such as not implemented branches.
|
||||
|
||||
Namely we will implement
|
||||
|
||||
- `todo`,
|
||||
- `unimplemented`, and
|
||||
- `unreachable`.
|
||||
|
||||
## Design
|
||||
|
||||
If we take the two languages mentioned above as examples, there are at least two
|
||||
ways how to implement them:
|
||||
|
||||
1. _panic_ when they are reached (as they do in Rust), or
|
||||
2. _raise_ an exception when they are reached (as they do in Kotlin).
|
||||
|
||||
I will choose raising an exception, since the closest equivalent of _panic_ in
|
||||
C++ would be `assert`s that are (by default) disabled in the _release builds_.
|
||||
|
||||
However I am too lazy to do:
|
||||
|
||||
```cpp
|
||||
throw todo();
|
||||
// or
|
||||
throw todo("optional note");
|
||||
```
|
||||
|
||||
Therefore we will implement exceptions and also wrap them in functions, so that
|
||||
we can do:
|
||||
|
||||
```cpp
|
||||
todo();
|
||||
// or
|
||||
todo("optional note");
|
||||
```
|
||||
|
||||
:::tip
|
||||
|
||||
Wrapping them in a function (or macro) will allow us to do a little magic trick.
|
||||
|
||||
:::
|
||||
|
||||
## Implementation
|
||||
|
||||
We're going to utilize the exceptions, so we'll need to include the `exception`
|
||||
header and we will start with a simple `_todo` exception class.
|
||||
|
||||
```cpp
|
||||
#include <exception>
|
||||
#include <string>
|
||||
|
||||
class _todo : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_todo() : cause("not yet implemented") {}
|
||||
_todo(std::string&& excuse) : cause("not yet implemented: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
```
|
||||
|
||||
In this case we have 2 constructors:
|
||||
|
||||
1. default constructor without any parameters that will return just
|
||||
`not yet implemented`
|
||||
2. and one parametrized with an “excuse” that will return string like:
|
||||
`not yet implemented: ‹excuse›`
|
||||
|
||||
If we were to use it now, we would need to do something like:
|
||||
|
||||
```cpp
|
||||
#include "placeholders.hpp"
|
||||
|
||||
int main() {
|
||||
throw _todo();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
## Wrapping in a function
|
||||
|
||||
I am a lazy person, so we will wrap the exception in a function that will throw
|
||||
it:
|
||||
|
||||
```cpp
|
||||
void todo() {
|
||||
throw _todo();
|
||||
}
|
||||
```
|
||||
|
||||
This can be used like:
|
||||
|
||||
```cpp
|
||||
#include "placeholders.hpp"
|
||||
|
||||
int main() {
|
||||
todo();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
## Magic trick
|
||||
|
||||
At the beginning I've mentioned that by wrapping the exceptions in a helper
|
||||
functions that will throw them, we can do a nice magic trick :smile: This trick
|
||||
will consist of formatted string and for that we will use
|
||||
[`std::format`](https://en.cppreference.com/w/cpp/utility/format/format) that is
|
||||
available since C++20.
|
||||
|
||||
We just need to add one more overload for our `todo()`:
|
||||
|
||||
```cpp
|
||||
#include <format>
|
||||
|
||||
template< class... Args >
|
||||
void todo(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _todo(std::format(fmt, args...));
|
||||
}
|
||||
```
|
||||
|
||||
## Finishing off with 2 more exceptions
|
||||
|
||||
Now we can repeat the same process for the other two exceptions I've mentioned
|
||||
|
||||
- `unimplemented`, and
|
||||
- `unreachable`.
|
||||
|
||||
In the end we should end up with something like this:
|
||||
|
||||
```cpp
|
||||
#include <exception>
|
||||
#include <format>
|
||||
#include <string>
|
||||
|
||||
class _todo : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_todo() : cause("not yet implemented") {}
|
||||
_todo(std::string&& excuse) : cause("not yet implemented: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
|
||||
void todo() { throw _todo(); }
|
||||
|
||||
template <class... Args>
|
||||
void todo(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _todo(std::format(fmt, args...));
|
||||
}
|
||||
|
||||
class _unimplemented : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_unimplemented() : cause("not implemented") {}
|
||||
_unimplemented(std::string&& excuse)
|
||||
: cause("not implemented: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
|
||||
void unimplemented() { throw _unimplemented(); }
|
||||
|
||||
template <class... Args>
|
||||
void unimplemented(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _unimplemented(std::format(fmt, args...));
|
||||
}
|
||||
|
||||
class _unreachable : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_unreachable() : cause("entered unreachable code") {}
|
||||
_unreachable(std::string&& excuse)
|
||||
: cause("entered unreachable code: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
|
||||
void unreachable() { throw _unreachable(); }
|
||||
|
||||
template <class... Args>
|
||||
void unreachable(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _unreachable(std::format(fmt, args...));
|
||||
}
|
||||
```
|
||||
|
||||
:::info
|
||||
|
||||
Final source code: [`placeholders.hpp`](pathname:///files/cpp/exceptions-and-raii/placeholders/placeholders.hpp)
|
||||
|
||||
:::
|
5
cpp/07-exceptions-and-raii/_category_.yml
Normal file
5
cpp/07-exceptions-and-raii/_category_.yml
Normal file
|
@ -0,0 +1,5 @@
|
|||
label: Exceptions and RAII
|
||||
link:
|
||||
type: generated-index
|
||||
description: |
|
||||
Materials related to the exceptions or RAII in C++.
|
|
@ -0,0 +1,77 @@
|
|||
#include <exception>
|
||||
#include <format>
|
||||
#include <string>
|
||||
|
||||
class _todo : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_todo() : cause("not yet implemented") {}
|
||||
_todo(std::string&& excuse) : cause("not yet implemented: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Indicates unfinished code.
|
||||
*/
|
||||
void todo() { throw _todo(); }
|
||||
|
||||
/**
|
||||
* @brief Indicates unfinished code.
|
||||
* @param fmt an object that represents the format string
|
||||
* @param args arguments to be formatted
|
||||
*/
|
||||
template <class... Args>
|
||||
void todo(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _todo(std::format(fmt, args...));
|
||||
}
|
||||
|
||||
class _unimplemented : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_unimplemented() : cause("not implemented") {}
|
||||
_unimplemented(std::string&& excuse)
|
||||
: cause("not implemented: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Indicates unimplemented code by throwing with a message of “not implemented”.
|
||||
*/
|
||||
void unimplemented() { throw _unimplemented(); }
|
||||
|
||||
/**
|
||||
* @brief Indicates unimplemented code by throwing with a message of “not implemented”.
|
||||
* @param fmt an object that represents the format string
|
||||
* @param args arguments to be formatted
|
||||
*/
|
||||
template <class... Args>
|
||||
void unimplemented(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _unimplemented(std::format(fmt, args...));
|
||||
}
|
||||
|
||||
class _unreachable : public std::exception {
|
||||
std::string cause;
|
||||
|
||||
public:
|
||||
_unreachable() : cause("entered unreachable code") {}
|
||||
_unreachable(std::string&& excuse)
|
||||
: cause("entered unreachable code: " + excuse) {}
|
||||
virtual const char* what() const throw() { return cause.c_str(); }
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Indicates unreachable code.
|
||||
*/
|
||||
void unreachable() { throw _unreachable(); }
|
||||
|
||||
/**
|
||||
* @brief Indicates unreachable code.
|
||||
* @param fmt an object that represents the format string
|
||||
* @param args arguments to be formatted
|
||||
*/
|
||||
template <class... Args>
|
||||
void unreachable(std::format_string<Args...> fmt, Args&&... args) {
|
||||
throw _unreachable(std::format(fmt, args...));
|
||||
}
|
|
@ -0,0 +1,6 @@
|
|||
#include "placeholders.hpp"
|
||||
|
||||
int main() {
|
||||
todo("finish later ({})", "in 3 days");
|
||||
return 0;
|
||||
}
|
Loading…
Reference in a new issue