История изменений
Исправление shaplov, (текущая версия) :
У меня в общем и целом сердце успокоилось на следующем решении…
Я во-первых завел объект «указатель с размером»
template<class T> class sized_ptr
{
private:
T* _ptr{nullptr};
size_t _size;
public:
operator T*() const {return _ptr;};
size_t size() {return _size;};
sized_ptr(T* ptr, size_t size): _ptr{ptr}, _size{size} {};
~sized_ptr() {if (_ptr) free(_ptr);};
};
Для более абстрактной работы с подобного рода объектами, не ограничивающейся только ситуацией когда в конце добавлен массив, но и предустматривающий более кривые случаи.
А для случая когда у нас конкретно структура с массивом переменной длинны в конце, то для этого я создал объект pointer to Variable Length Array Terminated Object: VLATO_ptr. Ему надо в параметрах шаблона сообщить тип самого объекта и тип элемента массива в конце этого объекта.
Так же не надо оперировать понятием «размер структуры», а можно пользоваться понятием «размер массива»
template<class T, class ArrayT> class VLATO_ptr
{
private:
T* _ptr{nullptr};
size_t _length;
public:
operator T*() const {return _ptr;};
operator sized_ptr<T>() {sized_ptr<T> res(_ptr,size()); _ptr=NULL; return res;};
size_t length() {return _length;};
size_t size() {return sizeof(T) + _length * sizeof(ArrayT);};
VLATO_ptr(size_t length);
VLATO_ptr(T* ptr, size_t length): _ptr{ptr}, _length{length} {};
~VLATO_ptr() {if (_ptr) free(_ptr);}
};
template<class T, class ArrayT>
VLATO_ptr<T,ArrayT>::VLATO_ptr(size_t length)
{
_ptr = (T*) malloc(sizeof(T) + sizeof(ArrayT) * length);
_length = length;
}
В результате создаешь объект
VLATO_ptr<my_struct_t, double> vlato10(10);
Заполняешь его
((my_struct_t*) vlato10)->size = 10;
((my_struct_t*) vlato10)->p[3] = 11;
А после заполнения хранишь как sized_ptr
sized_ptr<my_struct_t> szo10 = vlato10;
пока не понадобиться скормить его сишному вызову. Тогда из него извлекаешь обычный указатель.
my_struct_t* ps10 = szo10;
Исправление shaplov, :
У меня в общем и целом сердце успокоилось на следующем решении…
Я во-первых завел объект «указатель с размером»
template<class T> class sized_ptr
{
private:
T* _ptr{nullptr};
size_t _size;
public:
operator T*() const {return _ptr;};
size_t size() {return _size;};
sized_ptr(T* ptr, size_t size): _ptr{ptr}, _size{size} {};
~sized_ptr() {if (_ptr) free(_ptr);};
};
Для более абстрактной работы с подобного рода объектами, не ограничивающейся только ситуацией когда в конце добавлен массив, но и предустматривающий более кривые случаи.
А для случая когда у нас конкретно структура с массивом переменной длинны в конце, то для этого я создал объект pointer to Variable Length Array Terminated Object: VALTO_ptr. Ему надо в параметрах шаблона сообщить тип самого объекта и тип элемента массива в конце этого объекта.
Так же не надо оперировать понятием «размер структуры», а можно пользоваться понятием «размер массива»
template<class T, class ArrayT> class VLATO_ptr
{
private:
T* _ptr{nullptr};
size_t _length;
public:
operator T*() const {return _ptr;};
operator sized_ptr<T>() {sized_ptr<T> res(_ptr,size()); _ptr=NULL; return res;};
size_t length() {return _length;};
size_t size() {return sizeof(T) + _length * sizeof(ArrayT);};
VLATO_ptr(size_t length);
VLATO_ptr(T* ptr, size_t length): _ptr{ptr}, _length{length} {};
~VLATO_ptr() {if (_ptr) free(_ptr);}
};
template<class T, class ArrayT>
VLATO_ptr<T,ArrayT>::VLATO_ptr(size_t length)
{
_ptr = (T*) malloc(sizeof(T) + sizeof(ArrayT) * length);
_length = length;
}
В результате создаешь объект
VLATO_ptr<my_struct_t, double> vlato10(10);
Заполняешь его
((my_struct_t*) vlato10)->size = 10;
((my_struct_t*) vlato10)->p[3] = 11;
А после заполнения хранишь как sized_ptr
sized_ptr<my_struct_t> szo10 = vlato10;
пока не понадобиться скормить его сишному вызову. Тогда из него извлекаешь обычный указатель.
my_struct_t* ps10 = szo10;
Исправление shaplov, :
У меня в общем и целом сердце успокоилось на следующем решении…
Я во-первых завел объект «указатель с размером»
template<class T> class sized_ptr
{
private:
T* _ptr{nullptr};
size_t _size;
public:
operator T*() const {return _ptr;};
size_t size() {return _size;};
sized_ptr(T* ptr, size_t size): _ptr{ptr}, _size{size} {};
~sized_ptr() {if (_ptr) free(_ptr);};
};
Для более абстрактной работы с подобного рода объектами, не ограничивающейся только ситуацией когда в конце добавлен массив, но и предустматривающий более кривые случаи.
А для случая когда у нас конкретно структура с массивом переменной длинны в конце, то для этого я создал объект pointer to Variable Length Array Terminated Object: VALTO_ptr. Ему надо в параметрах шаблона сообщить тип самого объекта и тип элемента массива в конце этого объекта.
Так же не надо оперировать понятием «размер структуры», а можно пользоваться понятием «размер массива»
template<class T, class ArrayT> class VLATO_ptr
{
private:
T* _ptr{nullptr};
size_t _length;
public:
void print();
operator T*() const {return _ptr;};
operator sized_ptr<T>() {sized_ptr<T> res(_ptr,size()); _ptr=NULL; return res;};
size_t length() {return _length;};
size_t size() {return sizeof(T) + _length * sizeof(ArrayT);};
VLATO_ptr(size_t length);
VLATO_ptr(T* ptr, size_t length): _ptr{ptr}, _length{length} {};
~VLATO_ptr() {if (_ptr) free(_ptr);}
};
template<class T, class ArrayT>
VLATO_ptr<T,ArrayT>::VLATO_ptr(size_t length)
{
_ptr = (T*) malloc(sizeof(T) + sizeof(ArrayT) * length);
_length = length;
}
В результате создаешь объект
VLATO_ptr<my_struct_t, double> vlato10(10);
Заполняешь его
((my_struct_t*) vlato10)->size = 10;
((my_struct_t*) vlato10)->p[3] = 11;
А после заполнения хранишь как sized_ptr
sized_ptr<my_struct_t> szo10 = vlato10;
пока не понадобиться скормить его сишному вызову. Тогда из него извлекаешь обычный указатель.
my_struct_t* ps10 = szo10;
Исправление shaplov, :
У меня в общем и целом сердце успокоилось на следующем решении…
Я во-первых завел объект «указатель с размером»
template<class T> class sized_ptr
{
private:
T* _ptr{nullptr};
size_t _size;
public:
void print();
operator T*() const {return _ptr;};
size_t size() {return _size;};
sized_ptr(T* ptr, size_t size): _ptr{ptr}, _size{size} {};
~sized_ptr() {if (_ptr) free(_ptr);};
};
Для более абстрактной работы с подобного рода объектами, не ограничивающейся только ситуацией когда в конце добавлен массив, но и предустматривающий более кривые случаи.
А для случая когда у нас конкретно структура с массивом переменной длинны в конце, то для этого я создал объект pointer to Variable Length Array Terminated Object: VALTO_ptr. Ему надо в параметрах шаблона сообщить тип самого объекта и тип элемента массива в конце этого объекта.
Так же не надо оперировать понятием «размер структуры», а можно пользоваться понятием «размер массива»
template<class T, class ArrayT> class VLATO_ptr
{
private:
T* _ptr{nullptr};
size_t _length;
public:
void print();
operator T*() const {return _ptr;};
operator sized_ptr<T>() {sized_ptr<T> res(_ptr,size()); _ptr=NULL; return res;};
size_t length() {return _length;};
size_t size() {return sizeof(T) + _length * sizeof(ArrayT);};
VLATO_ptr(size_t length);
VLATO_ptr(T* ptr, size_t length): _ptr{ptr}, _length{length} {};
~VLATO_ptr() {if (_ptr) free(_ptr);}
};
template<class T, class ArrayT>
VLATO_ptr<T,ArrayT>::VLATO_ptr(size_t length)
{
_ptr = (T*) malloc(sizeof(T) + sizeof(ArrayT) * length);
_length = length;
}
В результате создаешь объект
VLATO_ptr<my_struct_t, double> vlato10(10);
Заполняешь его
((my_struct_t*) vlato10)->size = 10;
((my_struct_t*) vlato10)->p[3] = 11;
А после заполнения хранишь как sized_ptr
sized_ptr<my_struct_t> szo10 = vlato10;
пока не понадобиться скормить его сишному вызову. Тогда из него извлекаешь обычный указатель.
my_struct_t* ps10 = szo10;
Исходная версия shaplov, :
У меня в общем и целом сердце успокоилось на следующем решении…
Я во-первых завел объект «указатель с размером»
template<class T> class sized_ptr
{
private:
T* _ptr{nullptr};
size_t _size;
public:
void print();
operator T*() const {return _ptr;};
size_t size() {return _size;};
sized_ptr(T* ptr, size_t size): _ptr{ptr}, _size{size} {};
~sized_ptr() {if (_ptr) free(_ptr);};
};
Для более абстрактной работы с подобного рода объектами, не ограничивающейся только ситуацией когда в конце добавлен массив, но и предустматривающий более кривые случаи.
А для случая когда у нас конкретно структура с массивом переменной длинны в конце, то для этого я создал объект pointer to Variable Length Array Terminated Object: VALTO_ptr. Ему надо в параметрах шаблона сообщить тип самого объекта и тип элемента массива в конце этого объекта.
Так же не надо оперировать понятием «размер структуры», а можно пользоваться понятием «размер массива»
template<class T, class ArrayT> class VLATO_ptr
{
private:
T* _ptr{nullptr};
size_t _length;
public:
void print();
operator T*() const {return _ptr;};
operator sized_ptr<T>() {sized_ptr<T> res(_ptr,size()); _ptr=NULL; return res;};
size_t length() {return _length;};
size_t size() {return sizeof(T) + _length * sizeof(ArrayT);};
VLATO_ptr(size_t length);
VLATO_ptr(T* ptr, size_t length): _ptr{ptr}, _length{length} {};
~VLATO_ptr() {if (_ptr) free(_ptr);}
};
template<class T, class ArrayT>
VLATO_ptr<T,ArrayT>::VLATO_ptr(size_t length)
{
_ptr = (T*) malloc(sizeof(T) + sizeof(ArrayT) * length);
_length = length;
}
В результате создаешь объект
VLATO_ptr<my_struct_t, double> vlato10(10);
Заполняешь его
((my_struct_t*) vlato10)->size = 10;
((my_struct_t*) vlato10)->p[3] = 11;
А после заполнения хранишь как sized_ptr
sized_ptr<my_struct_t> szo10 = vlato10;
пока не понадобиться скормить его сишному вызову. Тогда из него извлекаешь обычный указатель.
y_struct_t* ps10 = szo10;