Comment convertir un vecteur en tableau

Comment convertir un std::vector<double>en un double array[]?

Il y a une astuce assez simple à faire, car la spécification garantit maintenant que les vecteurs stockent leurs éléments de manière contiguë:

std::vector<double> v;
double* a = &v[0];

Pourquoi? Vous devez clarifier: avez-vous besoin d'un pointeur sur le premier élément d'un tableau ou d'un tableau?

Si vous appelez une fonction API qui attend la première, vous pouvez le faire do_something(&v[0], v.size()), où vest un vecteur de doubles. Les éléments d'un vecteur sont contigus.

Sinon, il vous suffit de copier chaque élément:

double arr[100];
std::copy(v.begin(), v.end(), arr);

Assurez-vous non seulement qu'il arrest assez grand, mais qu'il arrest rempli, ou que vous avez des valeurs non initialisées.

Pour C ++ 11 , vector.data()fera l'affaire.

vector<double> thevector;
//...
double *thearray = &thevector[0];

Il est garanti que cela fonctionne selon la norme, mais il y a quelques mises en garde: en particulier, veillez à n'utiliser thearrayque pendant qu'il thevectorest dans le champ d'application.

Les vecteurs sont efficacement des réseaux sous la peau. Si vous avez une fonction:

void f( double a[]);

vous pouvez l'appeler comme ceci:

vector <double> v;
v.push_back( 1.23 )
f( &v[0] );

Vous ne devriez jamais avoir besoin de convertir un vecteur en une véritable instance de tableau.

Quant à std::vector<int> vecvec pour obtenir int*, vous pouvez utiliser deux méthodes:

1. int * arr = & vec [0];

2. int * arr = vec.data ();

Si vous souhaitez convertir n'importe quel type de Tvecteur en T* array, remplacez simplement ce qui précède intparT .

Je vais vous montrer pourquoi les deux ci-dessus fonctionnent, pour une bonne compréhension?

std::vector est un tableau dynamique essentiellement.

Membre des données principales comme ci-dessous:

template <class T, class Alloc = allocator<T>>
class vector{
    public:
        typedef T          value_type;
        typedef T*         iterator;
        typedef T*         pointer;
        //.......
    private:
        pointer start_;
        pointer finish_;
        pointer end_of_storage_;

    public:
        vector():start_(0), finish_(0), end_of_storage_(0){}
    //......
}

le range (start_, end_of_storage_) est toute la mémoire du tableau allouée par le vecteur;

le range(start_, finish_) est toute la mémoire matricielle du vecteur utilisé;

le range(finish_, end_of_storage_) est la mémoire de tableau de sauvegarde.

Par exemple, comme pour un vecteur vec. qui a {9, 9, 1, 2, 3, 4} est le pointeur peut aimer le ci-dessous.

So &vec[0]= start_ (address.) (Start_ est équivalent à int * array head)

Dans c++11 la data()fonction membre, renvoyez simplement start_

pointer data()
{ 
     return start_; //(equivalent to `value_type*`, array head)
}

Nous pouvons le faire en utilisant la méthode data (). C ++ 11 fournit cette méthode.

Extrait de code

#include<bits/stdc++.h>
using namespace std;


int main()
{
  ios::sync_with_stdio(false);

  vector<int>v = {7, 8, 9, 10, 11};
  int *arr = v.data();

  for(int i=0; i<v.size(); i++)
  {
    cout<<arr[i]<<" ";
  }

  return 0;
}

std::vector<double> vec;
double* arr = vec.data();

Si vous avez une fonction, alors vous avez probablement ceci: foo(&array[0], array.size());. Si vous avez réussi à vous retrouver dans une situation où vous avez besoin d'un tableau, vous devez refactoriser, les vecteurs sont essentiellement des tableaux étendus, vous devez toujours les utiliser.

Vous pouvez faire quelque chose comme ça

vector <int> id;
vector <double> v;

if(id.size() > 0)
{
    for(int i = 0; i < id.size(); i++)
    {
        for(int j = 0; j < id.size(); j++)
        {
            double x = v[i][j];
            cout << x << endl;
        }
    }
}