如何在不需要多个新运算符的情况下编写此代码？

Question

I have a generic code with template <class T> that I want it to work without the need of T() so for the copy constructor I have this:

template <class T>
SortedList<T>::SortedList(const SortedList<T>& list):
  data(new T*[list.max_size])
 ,size(list.size)
 ,max_size(list.max_size)
 {
     for (int i = 0; i < size; i++)
     {
         T* new_element=new T(*(list.data[i]));//my problem
        data[i]=new_element;
     }
 }

and it works fine , and I don't have any valgrind errors or any kind of error But I have learned that it is not good coding to have more than one new in your code, so I want to write a code that works without the new so I tried this :

T* new_element=& T(*(list.data[i]));

here there is an error : taking address of temporary

does anyone know what should I do now?

Answer 1

If you do this:

template <class T>
SortedList<T>::SortedList(const SortedList<T>& list):
  data(new T*[list.max_size])
 ,size(list.size)
 ,max_size(list.max_size)
 {
     for (int i = 0; i < size; i++)
     {
         T* new_element=new T(*(list.data[i]));
        data[i]=new_element;
     }
 }

You are copying all the elements of the other SortedList<T> . I am not sure where you heard this:

I have learned that it is not good coding to have more than one new in your code.

It is a good practice to stay away from dynamic allocation and use pre-coded containers. From the sound of SortedList , I'd say you want a std::set instead.

If it is acceptable for your container to use the other container's elements, you can do this:

template <class T>
SortedList<T>::SortedList(const SortedList<T>& list):
  data(new T*[list.max_size])
 ,size(list.size)
 ,max_size(list.max_size)
 {
     for (int i = 0; i < size; i++)
     {
         T* new_element= list.data[i];
        data[i]=new_element;
     }
 }

This could pose some problems , because if you modify the first SortedList<T> 's elements, it would modify the second's, so you probably don't want to do this.

The reason you cannot do this:

T* new_element=& T(*(list.data[i]));

Is because *list.data[i] is a temporary variable, and it is destructed as soon as you exit the current iteration of the for loop. If you take it's address, as soon as you try to modify it, you will get an error, as the element does no longer exist. (It has been destructed.) I would recommend that you keep your code the same for now, or even better, use a different container.

Another answer to this question proposes using this:

std::memcpy(data, list.data, list.size * sizeof(T))

The problem with this, is, as @AndyG stated:

Gotta be really careful with something like this. It will only work for trivially relocatable types, not generic T.

The other answer also proposed doing std::copy . This may work for your purpose, as it is higher level, and does all the work with new behind the scenes. To use it, you would do this:

std::copy(list.data[0], list.data[list.size-1], data[0]);