ссылка на локальный вектор - C/C++

Здравствуйте, watchmaker, Вы писали:

W>Здравствуйте, uzhas, Вы писали:

U>>рекомендую обратиться к Стандарту за более точной формулировкой:
U>>начни отсюда

W>Да там есть прямым текстом про всю эту ситуацию рассказано:

W>

W>The lifetime of a temporary bound to the returned value in a function return statement (6.6.3) is not
W>extended; the temporary is destroyed at the end of the full-expression in the return statement.

watchmaker, это ен означает, что при этом константная ссылка становится невалидной
семантика может быть таковой:
— cоздается копия const vector<float>(tmp) к которой и привязывается ссылка. а исходный объект tmp разрушается, как и положено

Здравствуйте, uzhas, Вы писали:

U>хотя это не про наш слцчай, ведь у нас нет temporary

Так дело в том, что если бы он и был, то это всё равно бы не помогло

Здравствуйте, watchmaker, Вы писали:

W>Так дело в том, что если бы он и был, то это всё равно бы не помогло

не запутывай нераспутываемое!

Здравствуйте, uzhas, Вы писали:

U>Здравствуйте, sci_reseacher, Вы писали:

_>>А как можно вернуть ссылку на std::vector<float> в данной ситуации, когда имеется float *?
U>зачем вам ссылка нужна? какая задача? возвращайте по значению

U>вот так:
U>

U>vector<float> getVector(){
U>  vector<float> tmp(X_,X_+size);
U>  return tmp;
U>}

U>vector<float> a1 = getVector(); // <-- valid
U>const vector<float>& a2 = getVector(); // <-- valid as well
U>

сколько раз здесь будет копирование объекта?

U>vector<float> getVector(){
U>  vector<float> tmp(X_,X_+size);
U>  return tmp;
U>}

U>vector<float> a1 = getVector(); // <-- valid
U>const vector<float>& a2 = getVector(); // <-- valid as well
U>

нужно сделать наследников D и C класса B, таких, что в одном данные хранятся в std::vector<T>, а в другом классе T* указывает на эти данные.

struct B {
    virtual const vector<float> &  getX() = 0 ;
};


struct C: public B {
    float *X;
    int size;
//    vector<float>  getX(){
//    vector<float> tmp(X,X+size);
//    return tmp;
//    }
};

struct D: public B {
    vector<float> X;
    const vector<float>  & getX(){
        return X;
    }
};

наверное лучший вариант переделать базовый класс


struct B {
    virtual vector<float> getX() = 0 ;
};

struct C: public B {
    float *X;
    int size;

    virtual vector<float> getX(){
        vector<float> tmp(X,X+size);
        return tmp;
    }
};

struct D: public B {
    vector<float> X;
    virtual vector<float>  getX(){
        return X;
    }
};

и использовать так

const vector<float> & w = d.getX(); // только вот здесь для D d нет ли лишней копии вектора? всегда работает return value optimization?

Здравствуйте, uzhas, Вы писали:

U>не запутывай нераспутываемое!

кстати, еще один нюанс : http://rsdn.ru/forum/cpp/5797699.1

Здравствуйте, sci_reseacher, Вы писали:

_>наверное лучший вариант переделать базовый класс
_>


_>struct B {
_>    virtual vector<float> getX() = 0 ;
_>};

_>struct C: public B {
_>    float *X;
_>    int size;

_>    virtual vector<float> getX(){
_>        vector<float> tmp(X,X+size);
_>        return tmp;
_>    }
_>};

_>struct D: public B {
_>    vector<float> X;
_>    virtual vector<float>  getX(){
_>        return X;
_>    }
_>};
_>

_>и использовать так
_>

_>const vector<float> & w = d.getX(); // только вот здесь нет ли лишней копии вектора?
_>

тут возможны альтернативы.
нужно оценить, насколько негативно в плане производительности, будет возврат вектора по значению. сколько там элементов ? как часто зовется ?
попробую набросать другие варианты:
1)

struct B {
  virtual void getX(vector<float>& result) = 0; <-- при таком подходе можно выиграть на аллокациях, если входной вектор имеет нужный capacity
};

2) оторвать указатель и размер от хранилища, которое владеет памятью

struct B {
  virtual float* getXBegin() = 0;
  virtual size_t getXSize() = 0;
};

3) можно объединить размер и указатель

struct B {
  virtual pair<float*, size_t> getX() = 0;
};

4) либо сделать\заюзать аналог array_view/string_view/string_ref/ link: http://stackoverflow.com/questions/34832090/whats-the-difference-between-span-and-array-view-in-the-gsl-library

5) либо прокинуть функтор для итерации по контейнеру (поэлементно, либо некими группами\страницами)

struct B {
  virtual void processX(std::function<float> f) = 0; //<-- f will be invoked for each "float" value
};

успехов

Здравствуйте, sci_reseacher, Вы писали:

_>Можно ли передавать ссылку на вектор, созданный локально?
_>

_>struct A
_>{
_>    float* X_;
_>    int size;
_>    const vector<float> & getX(){
_>        vector<float> tmp(X_,X_+size);
_>        return tmp;
_>    }
    
_>};
_>

_>P.S. другими словами будет ли метод getX правильно работать? Почему?

Мало того что дико выглядит, так и еще и работать не будет, но это на самом деле к счастью.
Время жизни твоего вектора ограничено временем жизни внутри функции. На что ты хочешь получить ссылку по окончании работы getX? Там же нет ничего, tmp будет гарантированно удален.
Второе замечание, прикинь что твой getX() сидит внутри большого цикла, вместо ожидаемой передачи ссылки на временный буфер, ты каждый раз его будешь строить.
Если тебе нужен временный буфер, то почему его не объявить в struct A?

Здравствуйте, uzhas, Вы писали:

В основном вектора будут большие, метод getX будет вызываться не часто, планируется использовать только по ссылке возвращаемое значение:

const vector<T> & w = d.getX();

Кроме того, внутри объекта класса решается какого размера вектор и какие значения он будет хранить.

Поэтому остановлюсь на варианте с возвратом вектора vector<T>.

U>тут возможны альтернативы.
U>нужно оценить, насколько негативно в плане производительности, будет возврат вектора по значению. сколько там элементов ? как часто зовется ?

Здравствуйте, uzhas, Вы писали:

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

 template<class T>
 struct AB
 {
 public:
   AB(){}
   void write( const size_t size, T* pT )
   {
     if (_data.size() < size)_data.resize( size );
     copy( pT, pT + size, _data.begin() );
   }

   const vector<T>& read(){ return _data; }
   size_t get_size(){ return _data.size(); }
 private:
   vector<T> _data;

 };

  float mydata[] = { 1.0f, 2.4f, 3.14f, 2.71f };
  AB<float> sci_buf;
  //sci_buf.w
  sci_buf.write( 4, (float*) mydata );
  auto& Vals = sci_buf.read(); 
 
  Vals[2] = 2.53f; <---- Хлоп! Ошибка компиляции, данные только на чтение

Здравствуйте, sci_reseacher, Вы писали:

_>P.S. другими словами будет ли метод getX правильно работать?

Да, он будет правильно работать. Он будет создавать такие проблемы, которые вы будете месяц искать по всей программе.

_>Почему?

Потому что vector состоит из управляющей структуры и массива значений. Управляющую структуру вы создаете на стеке. А это значит, что после выхода из функции, эта память станет свободным местом на стеке и по мере надобности будет переиспользованна, а ее предыдущее содержимое перетерто. Причем произойдет это не сразу, а когда стек дотянется до этого места.

Здравствуйте, peterbes, Вы писали:

P>Здравствуйте, uzhas, Вы писали:

P>Откуда такие сложности на пустом месте, интерфейсы, абстрактные классы, наследования, перегрузка, куча классов, если задача решается напрямую без академических извратов.

P>

P> template<class T>
P> struct AB
P> {
P> public:
P>   AB(){}
P>   void write( const size_t size, T* pT )
P>   {
P>     if (_data.size() < size)_data.resize( size );
P>     copy( pT, pT + size, _data.begin() );
P>   }

P>   const vector<T>& read(){ return _data; }
P>   size_t get_size(){ return _data.size(); }
P> private:
P>   vector<T> _data;

P> };
P>

P>  float mydata[] = { 1.0f, 2.4f, 3.14f, 2.71f };
P>  AB<float> sci_buf;
P>  //sci_buf.w
P>  sci_buf.write( 4, (float*) mydata );
P>  auto& Vals = sci_buf.read(); 
 
P>  Vals[2] = 2.53f; <---- Хлоп! Ошибка компиляции, данные только на чтение
P>

в одном классе мне нужен std::vector<T>, в другом T*, т.к. это две разные реализации класса, работающие на разных устройствах --- а пользователь их может выбирать.

удобнее всего вернуть ссылку:

const vector<T>& read(){ ... }

т.к. далее работать с классом проще.

P.S. "академические навороты" нужны чтобы "застолбить" единый интерфейс

Здравствуйте, sci_reseacher, Вы писали:

_>const vector<float> & w = d.getX(); // только вот здесь для D d нет ли лишней копии вектора? всегда работает return value optimization?

У тебя везде делается лишняя копия.
Используй ArrayView. И вместо хранения пары float*, size тоже храни ArrayView.

Здравствуйте, T4r4sB, Вы писали:

TB>Здравствуйте, sci_reseacher, Вы писали:

_>>const vector<float> & w = d.getX(); // только вот здесь для D d нет ли лишней копии вектора? всегда работает return value optimization?

TB>У тебя везде делается лишняя копия.
TB>Используй ArrayView. И вместо хранения пары float*, size тоже храни ArrayView.

а можно по сути разъяснить, как концепция "ArrayView" позволяет не делать лишней копии в указанной ситуации, когда требуется возвращать

const std::vector<T> &

а доступно: или контейнер

std::vector<T> w;

или указатель по которому можно читать

T *u;

Здравствуйте, sci_reseacher, Вы писали:

TB>>Используй ArrayView. И вместо хранения пары float*, size тоже храни ArrayView.

_>а можно по сути разъяснить, как концепция "ArrayView" позволяет не делать лишней копии в указанной ситуации, когда требуется возвращать
_>

_>const std::vector<T> &
_>

Опять же встречный вопрос: «кому требуется»? Концепция view как раз и подразумевает, что больше никому этот вектор не будет нужен, а возвращаться будет сам view. Соответственно, специализированный наследник сможет сам сконструировать view из своих данных (хоть из вектора, хоть из указателя).

То есть использование view позволяет один раз зафиксировать, что невладеющий доступ к массивам или строчкам в программе будет осуществляться через этот тип, а после этого дилеммы об возвращении const vector<int>& уже не возникнет, потому что в нём и не будет надобности.

_>в одном классе мне нужен std::vector<T>, в другом T*, т.к. это две разные реализации класса, работающие на разных устройствах --- а пользователь их может выбирать.

В чём разница, в первом вопросе этого не было, но было копирование.

Да и хрен с ним, а причем тут vector, который у вас возвращался дичайшим никогда невозвратным образом? Тогда берите слайсы над байтовым массивом и работайте напрямую, возвращая клиенту косвенные индексы

_>P.S. "академические навороты" нужны чтобы "застолбить" единый интерфейс

Можете пояснить?

Здравствуйте, sci_reseacher, Вы писали:

_>а можно по сути разъяснить, как концепция "ArrayView" позволяет не делать лишней копии в указанной ситуации, когда требуется возвращать
_>

_>const std::vector<T> &
_>

Потому что тебе не нужно возвращать ссылку на вектор. Тебе надо возвращать ArrayView. Тебе же нужно только что? Количество элементов и доступ к элементам. И всё. И этот ArrayView тебе это предоставил. Но надо, конечно, понимать, что время жизни ArrayView должно быть меньше, чем у вектора. Например, возвращать ArrayView на участок вектора, только что созданного на стеке — это очень плохо.
Смысл в том, что ArrayView можно построить на векторе без переголовы, а наоборот — нельзя.

Здравствуйте, uzhas, Вы писали:

U>или обратись к Стандарту

Не наш случай. Сей адепт интернет-толкований и научного тыка по компиляторам стандарт не признает.

Здравствуйте, sci_reseacher, Вы писали:

_>Можно ли передавать ссылку на вектор, созданный локально?
_>

_>struct A
_>{
_>    float* X_;
_>    int size;
_>    const vector<float> & getX(){
_>        vector<float> tmp(X_,X_+size);
_>        return tmp;
_>    }
    
_>};
_>

_>P.S. другими словами будет ли метод getX правильно работать? Почему?
1) А зачем tmp не временный? Можно же так:

struct A
{
    float* X_;
    int size;
    vector<float> getX(){
        return vector<float> tmp(X_,X_+size);
    }
    
_>};

2) Зачем возвращать ссылку? Можно же просто копию, в надежде на RVO, а если объект временным делать нельзя, то NRVO
3) Если С++11 и позже, то возвращаемое значение можно через мув-конструктор получать, что недорого
4) Главное, зачем вообще этот массив float'ов копировать в вектор? Можно же просто возвращать два указателя, в качестве итераторов?

	От:	uzhas
	Дата:	16.05.16 11:26
	Оценка:

	От:	_hum_
	Дата:	16.05.16 11:27
	Оценка:

	От:	watchmaker
	Дата:	16.05.16 11:30
	Оценка:

	От:	uzhas
	Дата:	16.05.16 11:33
	Оценка:

	От:	Current
	Дата:	16.05.16 12:04
	Оценка:

От:	Pzz	https://github.com/alexpevzner
Дата:	16.05.16 15:38
Оценка:

	От:	Erop
	Дата:	17.05.16 04:38
	Оценка:	+1