_>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(); // только вот здесь нет ли лишней копии вектора?
_>

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

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

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

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

_>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?
_>

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

struct B
{
    virtual float  getElementX(size_t index) = 0 ;
    virtual size_t getSizeX() = 0;
};

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

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

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

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

const vector<float> & getX(){
  return static_cast<const vector<float>&>(getVector());
}

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

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

__>>а можно обоснованно, а не голословно?

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

Temporary object lifetime

Temporary objects are created in the following situations: binding a reference to a prvalue, returning a prvalue from a function, conversion that creates a prvalue, lambda expression, (since C++11) copy-initialization that requires conversion of the initializer, list-initialization that constructs an std::initializer_list, (since C++11) and reference-initialization to a different but convertible type or to a bitfield.

struct A {};
struct B : A {};
B b;
const A& a = b;

12.2 Temporary objects [class.temporary]
1 Temporaries of class type are created in various contexts: binding a reference to a prvalue (8.5.3), returning
a prvalue (6.6.3), a conversion that creates a prvalue (4.1, 5.2.9, 5.2.11, 5.4), throwing an exception (15.1),
and in some initializations (8.5). [ Note: The lifetime of exception objects is described in 15.1. —end note ]
Even when the creation of the temporary object is unevaluated (Clause 5) or otherwise avoided (12.8), all
the semantic restrictions shall be respected as if the temporary object had been created and later destroyed.
[ Note: This includes accessibility (11) and whether it is deleted, for the constructor selected and for the
destructor. However, in the special case of a function call used as the operand of a decltype-specifier (5.2.2),
no temporary is introduced, so the foregoing does not apply to the prvalue of any such function call. —end
note ]

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

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>

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?

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

 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; <---- Хлоп! Ошибка компиляции, данные только на чтение

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>

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

const std::vector<T> &

std::vector<T> w;

T *u;

struct Base {
    virtual const std::vector<float> & setX() = 0;
};

struct A: public Base {
   std::vector<float> X;
   A(){ X.resize(10,55);}
   void work() { fill( X.begin(), X.end(), 25 );  }
   const std::vector<float> & setX() { return X; }
};

A a;
const std::vector<float> & x = a.setX();
copy( x.begin(), x.end(), ostream_iterator<float>( cout, " "));
a.work();
copy( x.begin(), x.end(), ostream_iterator<float>( cout, " "));

struct B: public Base {
   float* X;
   int size;
   B(){ /* .. */ }
   void work() { /* hard calc. for X */  }
   const std::vector<float> & setX() { return /* ..*/; }
};

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

struct A {
    std::vector<float> X;
    A(){ X.resize(10,5);}
    void work(void) { std::fill(X.begin(),X.end(),6); }
    arv::array_view<float>  getX(){
        return X;
    }
 };

struct B {
    float* X;
    B(){ X = new float[10];}
    void work(void) { for(int i=0; i<10; ++i) X[i] = i; }
    arv::array_view<float>  getX(){
        return {&X[0],10};
    }
 };

struct C {
    std::valarray<float> X;
    C(){ X.resize(5);}
    void work(void) { X += 3.14; }
    arv::array_view<float>  getX(){
        return {&X[0],X.size()};
    }
 };


A a;
const arv::array_view<float> & ref_a = a.getX();

B * b = new B;
const arv::array_view<float> & ref_b = b->getX();

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

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

struct C: public D {
    float *X;
    int size;
    void update() {
       X = X.data();
       size = X.size();
    }
};