Como inicializar std :: vector da matriz C-style?

Qual é a maneira mais barata de inicializar a std::vectorpartir de uma matriz no estilo C?

Exemplo: Na classe a seguir, eu tenho um vector, mas devido a restrições externas, os dados serão passados ​​como uma matriz no estilo C:

class Foo {
  std::vector<double> w_;
public:
  void set_data(double* w, int len){
   // how to cheaply initialize the std::vector?
}

Obviamente, eu posso ligar w_.resize()e depois fazer um loop sobre os elementos, ou ligar std::copy(). Existem métodos melhores?

Não esqueça que você pode tratar os ponteiros como iteradores:

w_.assign(w, w + len);

Você usa a palavra inicializar, portanto, não está claro se essa é uma atribuição única ou pode ocorrer várias vezes.

Se você precisar apenas de uma inicialização única, poderá colocá-la no construtor e usar o construtor de vetor de dois iteradores:

Foo::Foo(double* w, int len) : w_(w, w + len) { }

Caso contrário, use assign como sugerido anteriormente:

void set_data(double* w, int len)
{
    w_.assign(w, w + len);
}

Você pode 'aprender' o tamanho da matriz automaticamente:

template<typename T, size_t N>
void set_data(const T (&w)[N]){
    w_.assign(w, w+N);
}

Felizmente, você pode alterar a interface para set_data como acima. Ele ainda aceita uma matriz no estilo C como seu primeiro argumento. Acontece apenas por referência.

Como funciona

[Atualização: Veja aqui para uma discussão mais abrangente sobre como aprender o tamanho]

Aqui está uma solução mais geral:

template<typename T, size_t N>
void copy_from_array(vector<T> &target_vector, const T (&source_array)[N]) {
    target_vector.assign(source_array, source_array+N);
}

Isso funciona porque a matriz está sendo transmitida como uma referência a uma matriz. No C / C ++, você não pode passar uma matriz como uma função; em vez disso, ela se deteriorará para um ponteiro e você perderá o tamanho. Mas em C ++, você pode passar uma referência para a matriz.

Passar uma matriz por referência requer que os tipos correspondam exatamente. O tamanho de uma matriz faz parte de seu tipo. Isso significa que podemos usar o parâmetro N do modelo para aprender o tamanho para nós.

Pode ser ainda mais simples ter essa função que retorna um vetor. Com as otimizações apropriadas do compilador em vigor, isso deve ser mais rápido do que parece.

template<typename T, size_t N>
vector<T> convert_array_to_vector(const T (&source_array)[N]) {
    return vector<T>(source_array, source_array+N);
}

Bem, Pavel estava perto, mas há ainda uma solução mais simples e elegante para inicializar um contêiner seqüencial a partir de uma matriz de estilo CA.

No seu caso:

w_ (array, std::end(array))

• array nos dará um ponteiro para o início do array (não pegou o nome),
• std :: end (array) nos fornecerá um iterador para o final do array.

A resposta genérica rápida:

std::vector<double> vec(carray,carray+carray_size); 

ou pergunta específica:

std::vector<double> w_(w,w+len); 

com base no exposto acima : não esqueça que você pode tratar os ponteiros como iteradores

std::vector<double>::assigné o caminho a seguir, porque é pouco código . Mas como isso funciona, na verdade? Não redimensiona e copia? Na implementação do STL pela Microsoft, estou usando exatamente o mesmo.

Receio que não haja uma maneira mais rápida de implementar (re) inicializar o seu std::vector.