A coroutine func accepts a parameter by const reference in the code below:
#include <boost/asio.hpp>
#include <iostream>
namespace asio = boost::asio;
using asio::awaitable;
using asio::use_awaitable;
class Param
{
public:
Param(int val) : m_val(val)
{
std::cout << "Param constructor " << m_val << std::endl;
}
class Example
{
public:
Example()
{
m.emplace("abc", 13);
}
const int& findValue(const std::string& val) const
{
auto i = m.find(val);
if (i == m.end()) {
throw std::runtime_error(std::format("Key {} not found.", val));
}
return i->second;
}
int& findValue(const std::string& val)
{
return const_cast<int&>(
const_cast<const Example*>(this)->findValue(val));
}
#include <iostream>
#include <memory>
#include <string>
#include <vector>
struct IObject {
virtual ~IObject() = default;
/// Returns the name of the object.
virtual std::string getName() const = 0;
/// Prints a textual description of the object.
virtual void describe() const = 0;
/// Eats another object.
virtual bool eat(IObject* other) = 0;
};
QT implies that the client code will do qobject_cast that is actually dynamic_cast:
awl::ProcessTask<void> MarketModel::coPlaceOrder(OrderPtr p)
{
// Update SQLite databse...
// ...
// QT signals are used in both C++ and QML.
// They works with QObject*, and they are not aware of concrete types.
QObject::connect(p.get(), &OrderModel::statusChanged, this, &MarketModel::onOrderStatusChanged);
}
Compiles without warnings with MSVC:
class A
{
public:
void f(const int a);
};
void A::f(int a)
{
a = 10;
std::cout << a;
}
The code below demonstrates how standard C++23 synchronous generator works:
#include <boost/cobalt.hpp>
#include <iostream>
#include <generator>
namespace cobalt = boost::cobalt;
std::generator<int> numbers()
{
for (int i = 1; i <= 5; ++i)
{
co_yield i;
}
}
cd C:\dev\repos\boost_1_89_0
set OPENSSL_ROOT_DIR=C:/dev/libs/OpenSSL
set OPENSSL_USE_STATIC_LIBS=ON
bootstrap.bat
b2 cxxstd=20 install --with-system --with-thread --with-cobalt --prefix=C:/dev/libs/boost_1_89_0 --toolset=msvc-14.3 -s _WIN32_WINNT=0x0A00 link=static runtime-link=static variant=release address-model=64
b2 cxxstd=20 install --with-system --with-thread --with-cobalt --prefix=C:/dev/libs/boost_1_89_0 --toolset=msvc-14.3 -s _WIN32_WINNT=0x0A00 link=static runtime-link=static variant=debug address-model=64
The code below demonstrates how to access underlying range iterator by transformed iterator:
struct A
{
int x;
};
struct B
{
A* a;
};
std::vector<B> v;
int main()
{
auto a_range = v | std::views::transform(std::mem_fn(&B::a));
auto i = std::ranges::find(a_range, 5, std::mem_fn(&A::x));
A* a = *i;
B& b = *(i.base());
}
If no user-defined move assignment operators are provided for a class type, and all of the following is true:
- there are no user-declared copy constructors;
- there are no user-declared move constructors;
- there are no user-declared copy assignment operators;
- there is no user-declared destructor,
(more…)
Last time I have been working on a C++ binary serialization framework that allows to serialize simple data structures with a few lines of code. First, you add AWL_REFLECT macro to all your structures as follows:
#include "Awl/Reflection.h"
#include <string>
#include <vector>
#include <set>
struct A
{
int a;
bool b;
std::string c;
double d;
AWL_REFLECT(a, b, c, d)
};
