He escrito los rudimentos de una clase para crear estructuras dinámicas en C++. Los miembros de la estructura dinámica se almacenan contiguamente (en la medida en que indican mis pruebas) el mismo relleno que el compilador insertaría en la estructura estática equivalente. Por lo tanto, las estructuras dinámicas pueden convertirse implícitamente en estructuras estáticas para la interoperabilidad con las API existentes.¿En qué plataformas se bloqueará y cómo puedo mejorarlo?
En primer lugar, no confío en mí mismo para poder escribir código de calidad Boost que pueda compilar y trabajar en más o menos cualquier plataforma. ¿Qué partes de este código están peligrosamente en necesidad de modificación?
Tengo otra pregunta relacionada con el diseño: ¿es el acceso con plantillas de get
la única forma de proporcionar al compilador la información de tipo estático necesaria para el código de tipo seguro? Tal como está, el usuario de dynamic_struct
debe especificar el tipo de miembro al que está accediendo, siempre que lo acceda. Si ese tipo cambia, todos los de los accesos se vuelven inválidos, y causarán fallas espectaculares — o peor, fallan silenciosamente. Y no se puede atrapar en tiempo de compilación. Ese es un gran riesgo, y uno que me gustaría remediar.
Ejemplo de uso:
struct Test {
char a, b, c;
int i;
Foo object;
};
void bar(const Test&);
int main(int argc, char** argv) {
dynamic_struct<std::string> ds(sizeof(Test));
ds.append<char>("a") = 'A';
ds.append<char>("b") = '2';
ds.append<char>("c") = 'D';
ds.append<int>("i") = 123;
ds.append<Foo>("object");
bar(ds);
}
Y el código siguiente:
//
// dynamic_struct.h
//
// Much omitted for brevity.
//
/**
* For any type, determines the alignment imposed by the compiler.
*/
template<class T>
class alignment_of {
private:
struct alignment {
char a;
T b;
}; // struct alignment
public:
enum { value = sizeof(alignment) - sizeof(T) };
}; // class alignment_of
/**
* A dynamically-created structure, whose fields are indexed by keys of
* some type K, which can be substituted at runtime for any structure
* with identical members and packing.
*/
template<class K>
class dynamic_struct {
public:
// Default maximum structure size.
static const int DEFAULT_SIZE = 32;
/**
* Create a structure with normal inter-element padding.
*/
dynamic_struct(int size = DEFAULT_SIZE) : max(size) {
data.reserve(max);
} // dynamic_struct()
/**
* Copy structure from another structure with the same key type.
*/
dynamic_struct(const dynamic_struct& structure) :
members(structure.members), max(structure.max) {
data.reserve(max);
for (iterator i = members.begin(); i != members.end(); ++i)
i->second.copy(&data[0] + i->second.offset,
&structure.data[0] + i->second.offset);
} // dynamic_struct()
/**
* Destroy all members of the structure.
*/
~dynamic_struct() {
for (iterator i = members.begin(); i != members.end(); ++i)
i->second.destroy(&data[0] + i->second.offset);
} // ~dynamic_struct()
/**
* Get a value from the structure by its key.
*/
template<class T>
T& get(const K& key) {
iterator i = members.find(key);
if (i == members.end()) {
std::ostringstream message;
message << "Read of nonexistent member \"" << key << "\".";
throw dynamic_struct_access_error(message.str());
} // if
return *reinterpret_cast<T*>(&data[0] + i->second.offset.offset);
} // get()
/**
* Append a member to the structure.
*/
template<class T>
T& append(const K& key, int alignment = alignment_of<T>::value) {
iterator i = members.find(key);
if (i != members.end()) {
std::ostringstream message;
message << "Add of already existing member \"" << key << "\".";
throw dynamic_struct_access_error(message.str());
} // if
const int modulus = data.size() % alignment;
const int delta = modulus == 0 ? 0 : sizeof(T) - modulus;
if (data.size() + delta + sizeof(T) > max) {
std::ostringstream message;
message << "Attempt to add " << delta + sizeof(T)
<< " bytes to struct, exceeding maximum size of "
<< max << ".";
throw dynamic_struct_size_error(message.str());
} // if
data.resize(data.size() + delta + sizeof(T));
new (static_cast<void*>(&data[0] + data.size() - sizeof(T))) T;
std::pair<iterator, bool> j = members.insert
({key, member(data.size() - sizeof(T), destroy<T>, copy<T>)});
if (j.second) {
return *reinterpret_cast<T*>(&data[0] + j.first->second.offset);
} else {
std::ostringstream message;
message << "Unable to add member \"" << key << "\".";
throw dynamic_struct_access_error(message.str());
} // if
} // append()
/**
* Implicit checked conversion operator.
*/
template<class T>
operator T&() { return as<T>(); }
/**
* Convert from structure to real structure.
*/
template<class T>
T& as() {
// This naturally fails more frequently if changed to "!=".
if (sizeof(T) < data.size()) {
std::ostringstream message;
message << "Attempt to cast dynamic struct of size "
<< data.size() << " to type of size " << sizeof(T) << ".";
throw dynamic_struct_size_error(message.str());
} // if
return *reinterpret_cast<T*>(&data[0]);
} // as()
private:
// Map from keys to member offsets.
map_type members;
// Data buffer.
std::vector<unsigned char> data;
// Maximum allowed size.
const unsigned int max;
}; // class dynamic_struct
Tomo la votación para cerrar es porque SO no es responsable de pe Reviso mi código y cualquier pregunta que contenga un código que requiera desplazamiento automáticamente obtiene un voto negativo. Ah bueno. –
¿Qué hay de escribir esto como un artículo en CodeProject? O, si no se cierra aquí (tenerlo cerrado sería un desafortunado resultado en mi humilde opinión), entonces usted u otra persona podría atribuirle una recompensa. – John
Sí, puede que tenga que buscar lugares alternativos, aunque ya estaba considerando agregar una recompensa, y si queda algo de interés en la pregunta, ciertamente lo haré. –