Comment convertir un std::vector<double>
en un double array[]
?
Comment convertir un std::vector<double>
en un double array[]
?
Réponses:
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];
double*
qui pointe vers les mêmes données. Cette réponse fonctionne exactement pour ce cas
std::vector<double> v; double* a = v.data();
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ù v
est un vecteur de double
s. 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 arr
est assez grand, mais qu'il arr
est rempli, ou que vous avez des valeurs non initialisées.
size()
fonction du, std:vector
vous devrez utiliser new
ou malloc
faire cela. Comme cela a déjà été souligné (par vous), ce double arr[v.size()]
n'est pas valable. Utiliser un vecteur à la place de nouveau est une bonne idée, mais le point essentiel de la question est de savoir comment convertir un vecteur en tableau.
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 thearray
que pendant qu'il thevector
est dans le champ d'application.
empty()
, sinon cela invoquerait l'UB redouté.
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.
f( &v[0] );
pour votre dernière ligne
Quant à std::vector<int> vec
vec pour obtenir int*
, vous pouvez utiliser deux méthodes:
int * arr = & vec [0];
int * arr = vec.data ();
Si vous souhaitez convertir n'importe quel type de T
vecteur en T* array
, remplacez simplement ce qui précède int
parT
.
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.
#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;
}
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;
}
}
}