Создать объект минуя конструктор

struct MyClass {
 MyClass( int data ) : m_data(data) {}
 
 int m_data;
};

MyClass * mc = (MyClass *) malloc(sizeof(MyClass));

void foo(){}

// В шаблоне
t v1 = t{};
t v2 = t();

// Клиент, который линкуется со статической библиотекой
 
int rand_value(int const min, int const max);
 
void foo(); // Определена в статической библиотеке
void baz(); // Местная
 
void bar()
{
    using pfn = void(*)();
    pfn func = nullptr;
    if(rand_value(0, 1))
        func = foo;
    else
        func = baz;
    
    func();
}

SaveData2Undo( Stream & stream, TAG_ID, &MyClass );

template <class T>
void SaveData2Undo( Stream & stream, UInt32 id, const T * data )
{
 stream.write(id, sizeof(id));
 stream.write(data, sizeof(T));
}

template <class T>
void SaveData2Undo( Stream & stream, UInt32 id, const T * data )
{
    static_assert(std::is_trivially_copyable<T>::value, "Template type is not valid must be a trivial copyable");
 
    stream.write(id, sizeof(id));
    stream.write(data, sizeof(T));
}
 
template <class T>
    requires std::is_trivially_copyable<T>::value
void SaveData2Undo( Stream & stream, UInt32 id, const T * data ) { ... }
 
template<class T, std::enable_if<std::is_trivially_copyable<T>::value, int>::type = 0>
void SaveData2Undo( Stream & stream, UInt32 id, const T * data ) { ... }

struct MyClass {
 int * ptr;
};

class StreamSerializable { };
 
static_assert(std::is_base_of_v<StreamSerializable, T>, "Template type is not valid must inherit  StreamSerializable");
 
struct MyClass : StreamSerializable {
    int * ptr;
};

struct MyClass final : StreamSerializable {
    int * ptr;
};

#include <string_view>
#include <iostream>
#include <string>
#include <meta> 
 
template <typename T>
void print_structure_fields(const T& obj)
{
    constexpr auto ctx = std::meta::access_context::unchecked();
    
    static constexpr auto fields = std::define_static_array(
        std::meta::nonstatic_data_members_of(^^T, ctx)
    );
    
    template for (constexpr auto field : fields) 
    {
        constexpr std::string_view field_name = std::meta::identifier_of(field);
        auto field_value = obj.[:field:];
        std::cout << field_name << ": " << field_value << "\n";
    }
}
 
struct User 
{
    int id;
    std::string name;
    double rating;
};
 
struct Point 
{
    double x;
    double y;
    double z;
};
 
int main()
{
    User user{ .id = 101, .name = "Константин", .rating = 4.95 };
    std::cout << "=== Данные пользователя ===\n";
    print_structure_fields(user);
 
    std::cout << "\n";
 
    Point pt{ .x = 1.0, .y = 2.5, .z = -3.7 };
    std::cout << "=== Координаты точки ===\n";
    print_structure_fields(pt);
}

#include <iostream>
#include <meta>
 
struct some; 
 
constexpr std::meta::info info_1 = ^^some;
constexpr bool check_1 = std::meta::is_complete_type(info_1);
 
struct some{};
 
constexpr std::meta::info info_2 = ^^some;
constexpr bool check_2 = std::meta::is_complete_type(info_2);
 
int main() 
{
    std::cout << std::boolalpha;
    std::cout << "check_1: " << check_1 << "\n";
    std::cout << "check_2: " << check_2 << "\n";
}

#include <iostream>
#include <vector>
#include <meta>
 
// 1. Объявляем структуру как НЕПОЛНЫЙ тип (0 полей)
struct MyData;
 
// Функция-шаблон для проверки завершенности. 
consteval bool check_completeness()
{
    // is_complete_type легально принимает неполные типы на вход
    return std::meta::is_complete_type(^^MyData);
}
 
// --- Момент времени 1
// Проверяем тип в глобальном контексте ДО его наполнения полями
constexpr bool state_1 = check_completeness();
 
// --- момент времени 2 (Мутация типа)
// Глобальный consteval-блок. 
consteval
{
    std::vector<std::meta::info> fields;
    fields.push_back(std::meta::data_member_spec(^^int, {.name = "x"}));
    fields.push_back(std::meta::data_member_spec(^^float, {.name = "y"}));
    
    // Наполняем глобальный тип MyData полями
    std::meta::define_aggregate(^^MyData, fields);
}
 
// --- Момент времени 3
constexpr bool state_3 = check_completeness();
 
int main() 
{
    std::cout << std::boolalpha;
    std::cout << "Is MyData complete at Point 1: " << state_1 << "\n"; // Выведет: false
    std::cout << "Is MyData complete at Point 3: " << state_3 << "\n"; // Выведет: true
 
    // Теперь, когда тип гарантированно полный, мы можем безопасно узнать число полей
    constexpr std::meta::access_context ctx = std::meta::access_context::current();
    constexpr size_t final_fields = std::meta::nonstatic_data_members_of(^^MyData, ctx).size();
    std::cout << "Final fields count: " << final_fields << "\n"; // Выведет: 2
 
    // Объектом тоже можно пользоваться
    MyData instance{.x = 10, .y = 3.14f};
    std::cout << "Values: " << instance.x << ", " << instance.y << "\n";
}

struct S { int x; } s = { 42 };