How to change int16 array to vector<float>

I am setting up a new ASR server. Audio data is coming from a client, the audio data format is an int16 array (PCM data), and it should be changed to a vector<float> before ASR server engine.

I tried many times, but a compiler error happens like below:

error: invalid conversion from ‘int’ to  kaldi::MatrixResizeType’ [-fpermissive]

error: ‘vector’ was not declared in this scope
    wave_data = vector(std::begin(pcm_bytes), std::end(pcm_bytes)); //testing;

error: missing template arguments before ‘(’ token
    Vector wave_data = Vector(pcm_bytes, pcm_bytes + sizeof(pcm_bytes) / sizeof(pcm_bytes[0])); //testing;

Please tell me how I can change the array to a vector (int16 to float) without compile errors.

My source file:

BaseFloat pcm_bytes[MAX_FRAME_SIZE*CHANNELS*2];
opus_int16 out[MAX_FRAME_SIZE*CHANNELS]; //opus_int16

/* Convert to little-endian ordering. */
for(int i=0; i<CHANNELS*userinfo->asr_session_data->frame_size; i++)
{
  //pcm_byte
  pcm_bytes[2*i]=(BaseFloat)(out[i]&0xFF);
  pcm_bytes[2*i+1]=(BaseFloat)((out[i]>>8)&0xFF);
}
//vector init
Vector<BaseFloat> wave_data(CHANNELS*userinfo->asr_session_data->frame_size,0);
*wave_data = vector(std::begin(pcm_bytes), std::end(pcm_bytes));* //testing;  -> **error happend this line**    

My header file for the vector:

template<typename Real>
class Vector: public VectorBase<Real> {
 public:
  /// Constructor that takes no arguments.  Initializes to empty.
  Vector(): VectorBase<Real>() {}

  /// Constructor with specific size.  Sets to all-zero by default
  /// if set_zero == false, memory contents are undefined.
  explicit Vector(const MatrixIndexT s,
                  MatrixResizeType resize_type = kSetZero)
      : VectorBase<Real>() {  Resize(s, resize_type);  }

  /// Copy constructor from CUDA vector
  /// This is defined in ../cudamatrix/cu-vector.h
  template<typename OtherReal>
  explicit Vector(const CuVectorBase<OtherReal> &cu);

  /// Copy constructor.  The need for this is controversial.
  Vector(const Vector<Real> &v) : VectorBase<Real>()  { //  (cannot be explicit)
    Resize(v.Dim(), kUndefined);
    this->CopyFromVec(v);
  }

  /// Copy-constructor from base-class, needed to copy from SubVector.
  explicit Vector(const VectorBase<Real> &v) : VectorBase<Real>() {
    Resize(v.Dim(), kUndefined);
    this->CopyFromVec(v);
  }

  /// Type conversion constructor.
  template<typename OtherReal>
  explicit Vector(const VectorBase<OtherReal> &v): VectorBase<Real>() {
    Resize(v.Dim(), kUndefined);
    this->CopyFromVec(v);
  }

// Took this out since it is unsafe : Arnab
//  /// Constructor from a pointer and a size; copies the data to a location
//  /// it owns.
//  Vector(const Real* Data, const MatrixIndexT s): VectorBase<Real>() {
//    Resize(s);
  //    CopyFromPtr(Data, s);
//  }


  /// Swaps the contents of *this and *other.  Shallow swap.
  void Swap(Vector<Real> *other);

  /// Destructor.  Deallocates memory.
  ~Vector() { Destroy(); }

};