C++ 隐式类型转换：不是类或结构的成员

我试图找到一种更优雅的方法来读取和写入结构，而不是将其转换为空指针，然后像这样将大小传递给函数：

void write(void* value, size_t length);    //Write is some random write function

Type var;
write((void*)var,sizeof(Type));  

void write(VoidPtrReplacement* value);

Type var;
write(var);

#include <iostream>
#include <vector>

struct VoidPtrReplacement{
    const unsigned char *bytes;
    size_t size;

    template<typename T>
    VoidPtrReplacement(T &&t)
        : bytes(reinterpret_cast<unsigned char *>(&t)),
          size(sizeof(T))
    {
    }
};

void write(const VoidPtrReplacement &p)
{
    std::cout << "Write: " << (void *)p.bytes << ", " << p.size << " bytes"
          << std::endl;
}

class Foo {
    int i=4;
};

class Bar {
    char c=0;
    int b=3;
};

int main()
{
    Foo foo;
    Bar bar;

    std::cout << "Address of foo: " << &foo << std::endl;
    std::cout << "Address of bar: " << &bar << std::endl;

    write(foo);
    write(bar);
}

因此，我尝试创建一个方法，将任何类型隐式转换为结构，如下所示：

struct VoidPtrReplacement{
  uint8_t* bytes;
  size_t size;
};

然后我可以（如果我能找到一种方法，从任何其他类型隐式转换为这种类型）创建这样的读写函数：

void write(void* value, size_t length);    //Write is some random write function

Type var;
write((void*)var,sizeof(Type));  

void write(VoidPtrReplacement* value);

Type var;
write(var);

#include <iostream>
#include <vector>

struct VoidPtrReplacement{
    const unsigned char *bytes;
    size_t size;

    template<typename T>
    VoidPtrReplacement(T &&t)
        : bytes(reinterpret_cast<unsigned char *>(&t)),
          size(sizeof(T))
    {
    }
};

void write(const VoidPtrReplacement &p)
{
    std::cout << "Write: " << (void *)p.bytes << ", " << p.size << " bytes"
          << std::endl;
}

class Foo {
    int i=4;
};

class Bar {
    char c=0;
    int b=3;
};

int main()
{
    Foo foo;
    Bar bar;

    std::cout << "Address of foo: " << &foo << std::endl;
    std::cout << "Address of bar: " << &bar << std::endl;

    write(foo);
    write(bar);
}

不幸的是，我能找到的从任何其他类型转换为该类型的唯一方法是将VoidPtrReplacement设置为模板结构。我不想这样做，因为我创建的任何使用此结构的写函数也必须模板化

---

所以我的问题是：我可以创建一个不属于任何结构或类的隐式转换函数吗（或者如果有更好的方法），你不需要一个模板化的结构，只需要一个模板化的构造函数。大概是这样的：

void write(void* value, size_t length);    //Write is some random write function

Type var;
write((void*)var,sizeof(Type));  

void write(VoidPtrReplacement* value);

Type var;
write(var);

#include <iostream>
#include <vector>

struct VoidPtrReplacement{
    const unsigned char *bytes;
    size_t size;

    template<typename T>
    VoidPtrReplacement(T &&t)
        : bytes(reinterpret_cast<unsigned char *>(&t)),
          size(sizeof(T))
    {
    }
};

void write(const VoidPtrReplacement &p)
{
    std::cout << "Write: " << (void *)p.bytes << ", " << p.size << " bytes"
          << std::endl;
}

class Foo {
    int i=4;
};

class Bar {
    char c=0;
    int b=3;
};

int main()
{
    Foo foo;
    Bar bar;

    std::cout << "Address of foo: " << &foo << std::endl;
    std::cout << "Address of bar: " << &bar << std::endl;

    write(foo);
    write(bar);
}

---

很抱歉，我没有意识到你可以模板一个构造函数…这是非常有用的！谢谢