make_shared 如何绕过私有构造函数？ C++ 中文周刊 2024-11-23 第173期

#include <span>
#include <iostream>
#include <vector>
void processData(int* data, std::size_t size) {
    std::cout << "fucked";
}
void processData(std::span<int> data) {
    std::cout << "ok";
}
int main() {
    std::vector<int> v{ 1,3, 5,7, 9};
    processData({v.data(), v.size()});
}

#include <vector>
#include <string>
#include <iostream>
#include <optional>
struct Region {
        int dummy[100];
};
struct Widget
{
    Widget(Region const& region) {
    }
    Widget() = delete;
    Widget(Widget const&) = delete;
    Widget(Widget &&) = delete;
    Widget& operator=(Widget const&) = delete;
    Widget& operator=(Widget &&) = delete;
    static Widget CreateInside(Region const& region) {
        std::cout << "inside\n";
        return Widget(region);
    }
    static Widget CreateOutside(Region const& region) {
        std::cout << "outside\n";
        return Widget(region);
    }
private:
    int dummy[100];
};
struct WidgetInsideRegionCreator
{
    WidgetInsideRegionCreator(Region const& region) : m_region(region) {}
    operator Widget() { return Widget::CreateInside(m_region); }
    Region const& m_region;
};
template<typename F>
struct EmplaceHelper
{
    EmplaceHelper(F&& f) : m_f(f) {}
    operator auto() { return m_f(); }
    F& m_f;
};
int main()
{
    Region region;
    // construct with a Widget value
    std::optional<Widget> o0(WidgetInsideRegionCreator(region)); //函数声明我草
    std::optional<Widget> o{WidgetInsideRegionCreator(region)};
    std::optional<Widget> o2;
    // or place a Widget into the optional
    o2.emplace(WidgetInsideRegionCreator(region));
    // construct with a Widget value
    // 为什么这个不被解析成函数声明？
    std::optional<Widget> o3(
        EmplaceHelper([&] {
            return Widget::CreateInside(region);
        }));
    std::optional<Widget> o4;
    // or place a Widget into the optional
    o4.emplace(EmplaceHelper([&] {
            return Widget::CreateInside(region);
        }));
}

template<typename Map, typename Key, typename... Maker>
auto& ensure(Map&& map, Key&& key, Maker&&... maker)
{
    auto lower = map.lower_bound(key);
    if (lower == map.end() || map.key_comp()(lower->first, key)) {
        lower = map.emplace_hint(lower, std::forward<Key>(key),
            std::invoke(std::forward<Maker>(maker)...));
    }
    return lower->second;
}
auto& ensure_named_widget(std::string const& name)
{
    return ensure(widgets, name,
        [](auto&& name) { return std::make_shared<Widget>(name); },
        name);
}

template <class F>
struct lazy_call {
    F f;
    template <class T> operator T() { return f(); }
};
#define LAZY(expr) lazy_call{[&]{ return expr; }}
auto [iter, success] = map.try_emplace(key, LAZY(acquire_value()));

template<typename Map, typename Key, typename... Maker>
auto& ensure(Map&& map, Key&& key, Maker&&... maker)
{
    return *map.try_emplace(key, EmplaceHelper([&] {
        return std::invoke(std::forward<Maker>(maker)...);
    }).first;
}

auto& item =
    *widgets.try_emplace(name, EmplaceHelper([&] {
        return std::make_shared<Widget>(name); })).first;

// small, fast 64 bit hash function.
//
// https://github.com/N-R-K/ChibiHash
// https://nrk.neocities.org/articles/chibihash
//
// This is free and unencumbered software released into the public domain.
// For more information, please refer to <https://unlicense.org/>
#pragma once
#include <stdint.h>
#include <stddef.h>
static inline uint64_t
chibihash64__load64le(const uint8_t *p)
{
	return (uint64_t)p[0] <<  0 | (uint64_t)p[1] <<  8 |
	       (uint64_t)p[2] << 16 | (uint64_t)p[3] << 24 |
	       (uint64_t)p[4] << 32 | (uint64_t)p[5] << 40 |
	       (uint64_t)p[6] << 48 | (uint64_t)p[7] << 56;
}
static inline uint64_t
chibihash64(const void *keyIn, ptrdiff_t len, uint64_t seed)
{
	const uint8_t *k = (const uint8_t *)keyIn;
	ptrdiff_t l = len;
    // 写成了十六进制形式的 e（欧拉数）、π（圆周率）和黄金比例，最后一位调整为奇数（因为乘以偶数是不可逆的）
	const uint64_t P1 = UINT64_C(0x2B7E151628AED2A5);
	const uint64_t P2 = UINT64_C(0x9E3793492EEDC3F7);
	const uint64_t P3 = UINT64_C(0x3243F6A8885A308D);
	uint64_t h[4] = { P1, P2, P3, seed };
	for (; l >= 32; l -= 32) {
		for (int i = 0; i < 4; ++i, k += 8) {
			uint64_t lane = chibihash64__load64le(k);
			h[i] ^= lane;
			h[i] *= P1;
			h[(i+1)&3] ^= ((lane << 40) | (lane >> 24));
		}
	}
	h[0] += ((uint64_t)len << 32) | ((uint64_t)len >> 32);
	if (l & 1) {
		h[0] ^= k[0];
		--l, ++k;
	}
	h[0] *= P2; h[0] ^= h[0] >> 31;
	for (int i = 1; l >= 8; l -= 8, k += 8, ++i) {
		h[i] ^= chibihash64__load64le(k);
		h[i] *= P2; h[i] ^= h[i] >> 31;
	}
	for (int i = 0; l > 0; l -= 2, k += 2, ++i) {
		h[i] ^= (k[0] | ((uint64_t)k[1] << 8));
		h[i] *= P3; h[i] ^= h[i] >> 31;
	}
	uint64_t x = seed;
	x ^= h[0] * ((h[2] >> 32)|1);
	x ^= h[1] * ((h[3] >> 32)|1);
	x ^= h[2] * ((h[0] >> 32)|1);
	x ^= h[3] * ((h[1] >> 32)|1);
	// moremur: https://mostlymangling.blogspot.com/2019/12/stronger-better-morer-moremur-better.html
	x ^= x >> 27; x *= UINT64_C(0x3C79AC492BA7B653);
	x ^= x >> 33; x *= UINT64_C(0x1C69B3F74AC4AE35);
	x ^= x >> 27;
	return x;
}

#include  <iostream>
#include <string_view>
void print_me(std::string_view s) {
    printf("%s\n", s.data());
}
int main() {
  char next[] = {'n','e','x','t'};
  char hello[] = {'H','e','l','l','o', ' ',
                  'W','o','r','l','d'};
  std::string_view sub(hello, 5);
  std::cout << sub << "\n";
  print_me(sub);
}

#include <cstdio>
#include <cstring>
#include <iostream>
#include <string_view>
void print_me(std::string_view s) {
    printf("%s\n", s.data());
}
void paint(void* p, size_t n) {
    std::memset(p, 'X', n);
}
auto paint_fp = &paint;
int main() {
  {
    char buff[4096];
    paint_fp(buff, sizeof buff);
  }
  char hello[] = {'H','e','l','l','o', ' ',
                  'W','o','r','l','d'};
  std::string_view sub(hello, 5);
  std::cout << sub << "\n";
  print_me(sub);
}

#include <memory>
struct Arg1 {};
struct Arg2 {};
class MyComponent {
private:
    struct private_ctor_token {
        friend class MyComponent;
        private:
            private_ctor_token() = default;
    };
public:
    static auto make(Arg1 arg1, Arg2 arg2) -> std::shared_ptr<MyComponent> {
        return std::make_shared<MyComponent>(private_ctor_token{}, std::move(arg1), std::move(arg2));
    }
    // Ban copy and move constructors to avoid accidentally copying and moving
    // the object data into a stack instance.
    MyComponent(const MyComponent&) = delete;
    MyComponent(MyComponent&&) = delete;
    // Ban those bros too, that's optional.
    MyComponent& operator = (const MyComponent&) = delete;
    MyComponent& operator = (MyComponent&&) = delete;
    MyComponent(private_ctor_token, Arg1, Arg2) {  };
};
int main() {
    // MyComponent c({}, {}, {}); // Compilation error
}

#include <memory>
#include <xmmintrin.h>
#include <type_traits>
const size_t head = 0;
std::aligned_union<256, __m128i> storage;
//std::aligned_union_t<256, __m128i> storage;
int main() {
    __m128i* a = new (&storage) __m128i();
    __m128i* b = new ((char*)(&storage) + 0) __m128i();
    __m128i* c = new ((char*)&storage + head) __m128i();
}

 // To replace std::aligned_storage...
 template <typename T>
 class MyContainer {
    // [...]
   private:
-    std::aligned_storage_t<sizeof(T), alignof(T)> t_buff;
+    alignas(T) std::byte t_buff[sizeof(T)];
     // [...]
 };
 // To replace std::aligned_union...
 template <typename... Ts>
 class MyContainer {
    // [...]
   private:
-    std::aligned_union_t<0, Ts...> t_buff;
+    alignas(Ts...) std::byte t_buff[std::max({sizeof(Ts)...})];
     // [...]
 };

#include <string_view>
#include <string>
#include <concepts>
struct MetricSample{
    // To avoid implicit conversions, we immediately
    // added 'explicit', as all the best practices recommend.
    explicit MetricSample(std::same_as<double> auto val): value {val} {}
private:
    double value;
};
class Metrics {
public:
    // To make it clear for the user why to allocate memory for string and avoid redundant implicit copies,
    // we use a rvalue reference.
    // After all, this is a great way to show that the interface intends to take ownership of the string.
    // A user should explicitly perform a move operation.
    void set(std::string_view metric_name, MetricSample val, std::string&& comment) {};
    // void set(std::string_view metric_name, MetricSample val, std::same_as<std::string> auto&& comment) {};
};
int main() {
    Metrics m;
    auto val = MetricSample(1.0);
    m.set("Metric", val, 0);
}

#include <string>
#include <ranges>
#include <list>
#include <iostream>
#include <format>
void print_range(std::ranges::range auto&& r) {
    for (auto&& x: r) {
        std::cout << x << " ";
    }
    std::cout << "\n";
}
void test_drop_print() {
    std::list<int> ints = {1, 2, 3 ,4, 5};
    auto v = ints | std::views::drop(2);
    ints.push_front(-5);
    print_range(v);
}
void test_drop_print_before_after() {
    std::list<int> ints = {1, 2, 3 ,4, 5};
    auto v = ints | std::views::drop(2);
    print_range(v);
    ints.push_front(-5);
    print_range(v);
}
void test_take_print() {
    std::list<int> ints = {1, 2, 3 ,4, 5};
    auto v = ints | std::views::take(2);
    ints.push_front(-5);
    print_range(v);
}
void test_take_print_before_after() {
    std::list<int> ints = {1, 2, 3 ,4, 5};
    auto v = ints | std::views::take(2);
    print_range(v);
    ints.push_front(-5);
    print_range(v);
}
int main() {
    std::cout << "drop: \n";
    test_drop_print();
    std::cout << "------\n";
    test_drop_print_before_after();
    std::cout << "take: \n";
    test_take_print();
    std::cout << "------\n";
    test_take_print_before_after();

}

drop: 
2345
------
345
345
take:
-51
------
12
-51