Массивы-данные члены

[_Bers]

Итак, есть класс, принимающий на входе массив. При этом нужно выполнить его глубокое копирование. Вопрос: куда можно скопировать данные?

Требования к задаче:
1. Работа со стеком (никакой кучи)
2. Каждый объект класса должен получить собственную копию массива

Пример:

template<class tType>
class TPtrArray
{
public:
    TPtrArray():mPtrArray(0l), mNumberOfElement(0){}

    template<class tSrc, size_t tNum>
    TPtrArray(tSrc (&src)[tNum]) { mPtrArray = src;  mNumberOfElement = tNum; }
public:
    size_t GetNumOfElements()const { return mNumberOfElement;}
    size_t GetSize()const { return mNumberOfElement*sizeof(tType);}
    tType& operator[](size_t index)  {   return *(mPtrArray+index);  }
private:
    tType* mPtrArray;
    size_t mNumberOfElement;
};

Представленный класс указателей на обычные массивы не умеет выполнять глубокое копирование данных.

Нужно, что бы умел. И что бы разные объекты класса хранили собственные копии данных (объекты класса не являются синглтонами, и хотят уникальные копии данных).


зы: соль затеи в том, что бы научить класс "статических массивов" пересоздаваться с новым размером. Что бы можно было выполнять следующее:

int A[10];
int B[20];

TArray<int> test(A); //сделал глубокое копирование, и хранит внутри массив из 10 элементов

TArray<int> test = B; //сделал глубокое копирование, и хранит внутри массив из 20 элементов

И никакой кучи.

[pproger]

соль затеи в том, что бы научить класс "статических массивов" пересоздаваться с новым размером

int A[10];
int B[20];

TArray<int> test(A); //сделал глубокое копирование, и хранит внутри массив из 10 элементов

TArray<int> test = B; //сделал глубокое копирование, и хранит внутри массив из 20 элементов

где тут "пересоздавание"? если это написано в одном скопе - ошибка. если в разных - то получим два разных объекта

[_Bers]

что такое "скоп"?

[_Bers]

ааа... ну блин, опечатался:

int A[10];
int B[20];

TArray<int> test(A); //сделал глубокое копирование, и хранит внутри массив из 10 элементов

test = B; //сделал глубокое копирование, и хранит внутри массив из 20 элементов

[pproger]

область видимости.
если считать, что класс реализован, я не пойму в твоем примере, где тут "пересоздавание"?
если напишем

{
int A[10];
int B[20];

TArray<int> test(A);
TArray<int> test = B;
}

если напишем

{
int A[10];
int B[20];

TArray<int> test(A);

{
TArray<int> test = B;
}
}

то получим два разных объекта.

обобщу мой вопрос. что такое ПЕРЕСОЗДАВАНИЕ, и чем тебя не устроило например это?

template <typename T, size_t size>
class StaticArray {
public:
	StaticArray()
	{
		for (size_t i = 0; i < size; i++)
			m_array[i] = 0;
	}

	StaticArray(const T (&arr)[size])
	{
		for (size_t i = 0; i < size; i++)
			m_array[i] = arr[i];
	}

	size_t length() const
	{ return sizeof(m_array) / sizeof(m_array[0]); }

private:
	T m_array[size];
};

StaticArray<int, 100> arr; //пустой статический массив

int A[100];
int B[200];

StaticArray<int, 100> arr1(A);
StaticArray<int, 200> arr2 = B;

[pproger]

2_Bers

ааа... ну блин, опечатался

TArray<int> test(A); //сделал глубокое копирование, и хранит внутри массив из 10 элементов

test = B; //сделал глубокое копирование, и хранит внутри массив из 20 элементов

именно так на стеке не получится. только как я показал. и то, присваивать можно только классу такого же типа (с одинаковым типом элемента массива и одинаковым размером массива)

[_Bers]

Гм... в общем, мыслю я, любая работа с кучей тут будет более эффективная, нежели огород из шаблонов.

Даже если и получится нечто - вряд ли оно будет практично.

А покамест нерабочий вариант таков:

#include "TPtrArray.h"

template<class tType>
class TArray
{
public:
    template<class T, size_t N>   TArray& operator=(T (&arr)[N]) 
    { 
        //константная ссылка продлевает жизнь временного объекта
        const T (&cnst)[N] =  Create(arr); 
        
        //но с константным массивом много каши не сваришь

        //здесь компилятор фиксит,факт потери константности ссылки на временный объект
        //И уничтожает его.
        T (&tmp)[N] = const_cast<T (&)[N]>(cnst); 
        
        //В итоге указатель на простой массив содержит мусор
        mArray = tmp; return *this; 
    }
public:
    //Создаем массив, и возвращаем его по ссылке
    template<class T, size_t N>
    T (&Create(  T (&arr)[N] )   )[N]
    {
        T tmp[N]; for(size_t i=0;i<N;++i ) { tmp[i]= arr[i]; }
        return tmp; 
    }
private:
    TPtrArray<tType> mArray;
};

Идея может быть в том, что бы создавать временный объект, и продлевать его время жизни за счет константной ссылки.

При этом, такой "массив" можно будет использовать только как временный приемник данных. Он сможет принять данные, и попридержать их, пока они не будут скопированы куда либо вызывающей стороной. После чего, временный объект можно будет спокойно уничтожить.

Предполагаю - даже если получится, то решение будет сложным, шаблонным, и не гибким. А посему поделка не взлетит...

Можно ещё хранить данные в качестве static локальных массивов. Но такая жесть приведет к усложнению поделки до безобразия: один статик массив на все объекты класса. К тому же, каждый очередной массив уникальной размерности будет приводить к разрастанию кода инстанцированного класса, и замедлять компиляцию.

[netrino]

Сообщение от _Bers

        //константная ссылка продлевает жизнь временного объекта
        const T (&cnst)[N] =  Create(arr); 
        
        //но с константным массивом много каши не сваришь

        //здесь компилятор фиксит,факт потери константности ссылки на временный объект
        //И уничтожает его.
        T (&tmp)[N] = const_cast<T (&)[N]>(cnst);

Глупости, в C++ нет ни уборщика мусора, ни автоматического подсчёта ссылок, потому никакие константные ссылки не спасут локальные данные функции от уничтожения.
А вообще, не понятно в чём затея этого дела. Если массивы фиксированной длины, то почему не воспользоваться тем кодом, что привёл pproger, но с дополнительным свойством, определяющим текущий размер массива и перегруженным оператором присваивания. Сам массив выделять с запасом.

  StaticArray<int, 200> arr; // выделили 200 элементов, сюда влезет и a и b
  int a[100], b[150];
  arr = a;
  std::cout << arr.capacity() << std::endl; // 200
  std::cout << arr.size() << std::endl; // 100
  arr = b;

[_Bers]

Сообщение от netrino

Глупости, в C++ нет ни уборщика мусора, ни автоматического подсчёта ссылок, потому никакие константные ссылки не спасут локальные данные функции от уничтожения.

По стандарту, пока жива константная ссылка на временный объект, этот объект будет жив.
Есть любопытное обсуждение этого явления из области "когда мальчики тупят, им на помощь приходят девочки"
http://alenacpp.blogspot.com/2008/01/const.html

Сообщение от netrino

А вообще, не понятно в чём затея этого дела. Если массивы фиксированной длины...

Принимающая сторона не делает предположений о размере получаемого массива.

Это значит, что принимающая сторона принимает объект, который будет инкапсулировать внутри себя эту информацию.

При этом важно, что бы пришедшие данные были скопированы, и стали уникальной собственностью принимающей стороны (а не просто указатель на внешние данные).

[netrino]

Сообщение от _Bers

По стандарту, пока жива константная ссылка на временный объект, этот объект будет жив.

Не знал, круто. Только содержимое массива всё равно будет уничтожено после выхода из функции.
И кстати, "фиксим константность" не сработает, так как в области видимости всё ещё остаётся константная ссылка и данные будут уничтожены только по выходу из текущей области видимости.

Сообщение от _Bers

Есть любопытное обсуждение этого явления из области "когда мальчики тупят, им на помощь приходят девочки"
http://alenacpp.blogspot.com/2008/01/const.html

При чём здесь "девочки", когда по ссылке перевод статьи Герба Саттера?)

Сообщение от _Bers

Принимающая сторона не делает предположений о размере получаемого массива.

Это значит, что принимающая сторона принимает объект, который будет инкапсулировать внутри себя эту информацию.

При этом важно, что бы пришедшие данные были скопированы, и стали уникальной собственностью принимающей стороны (а не просто указатель на внешние данные).

Не делать предположений едва ли получится, ведь размер внутреннего массива необходимо специфицировать при объявлении объекта класса.