La meilleure façon de diviser un vecteur en deux petits tableaux?

Ce que je suis en train de faire:

Je suis en train de séparer un vecteur en deux tableaux distincts. L'actuel int vecteur contient un élément par ligne dans un fichier texte. Le fichier texte est une liste d'entiers aléatoires.

Comment j'envisage de faire:

Mon idée est de créer deux int ensembles, puis itérer sur l'ensemble du vecteur et de la copie n/2 éléments de chacun des tableaux.

Ce que je voudrais savoir:

Quelle est la façon la plus élégante de l'accomplissement de ma tâche? J'ai le sentiment que je peux le faire sans parcourir le vecteur à plusieurs reprises.

Code:

#include <vector>
#include <fstream>
#include <iterator>
#include <iostream>
using namespace std;

vector<int> ifstream_lines(ifstream& fs)
{
  vector<int> out;
  int temp;
  while(fs >> temp)
  {
    out.push_back(temp);
  }
  return out;
}

vector<int> MergeSort(vector<int>& lines)
{
  int split = lines.size() / 2;
  int arrayA[split];
  int arrayB[split];
}

int main(void) 
{
  ifstream fs("textfile.txt");
  vector<int> lines;
  lines = ifstream_lines(fs);

  return 0;
}

Merci 🙂

Je vous recommande de quelque chose de la <algorithm> en-tête (en.cppreference.com/w/cpp/algorithm). std::copy ou std::move pourrait être d'intérêt.
J'aime la façon dont la question est posée. Vous ne voyez pas bien structuré à ce genre de questions provenant de nouveaux utilisateurs, très souvent.
si vous n'avez pas l'intention de modifier la taille des 2 tables, vous pouvez jeter un oeil à array_view

InformationsquelleAutor mightcouldb1 | 2012-03-21

c++fstream split stdvector

60

Utiliser des itérateurs.
```
std::vector<int> lines;
//fill
std::size_t const half_size = lines.size() / 2;
std::vector<int> split_lo(lines.begin(), lines.begin() + half_size);
std::vector<int> split_hi(lines.begin() + half_size, lines.end());
```
Depuis itérateur plages représentent la moitié des plages ouvertes [begin, end), vous n'avez pas besoin d'ajouter 1 à la seconde commencer itérateur: lines.begin() + half_size n'est pas copié sur le premier vecteur.

Remarque que des choses comme
```
int split = lines.size() / 2;
int arrayA[split];
int arrayB[split];
```
Ne sont pas la norme C++ (et pas portable). Ce sont ce qu'on appelle variable de tableaux de longueur (VLAs, pour faire court) et sont un C99 chose. Certains compilateurs ont eux comme une extension lors de la compilation du code C++ (GCC, Clang). Toujours compiler avec -pedantic pour obtenir un avertissement. Ces VLAs loi funky pour les non-POD types et ne sont généralement pas utile, puisque vous ne pouvez pas même les renvoyer.
- Très bonne réponse, +1 pour le "vous n'avez pas besoin d'ajouter 1 à la seconde commencer itérateur"
InformationsquelleAutor Xeo
2

Si vous avez seulement besoin d'une référence à l'un des numéros sans les manipuler, alors vous pouvez faire:
```
int *array_1 = &lines[0];
int *array_2 = &lines[lines.size() / 2];
```
array_1 et array_2 sont, en fait, les pointeurs de début et de milieu des vecteur. Cela fonctionne depuis STL garantit que les vecteurs de stocker leurs éléments à l'intérieur d'une mémoire continue.
Notez que la référence à des lignes.begin() ne peut pas être utilisé pour cela.

InformationsquelleAutor Israel Unterman

Si vous ne pouvez pas utiliser le code de Xeo réponse en raison de la rigidité du compilateur de règles ou vous voulez plus de façon générique, essayez std::advance:

#include <vector>
#include <iterator>

size_t middle = input.size()/2;
std::vector<int>::const_iterator middleIter(input.cbegin());
std::advance(middleIter, middle);

std::vector<int> leftHalf(input.begin(), middleIter);
std::vector<int> rightHalf(middleIter, input.end());

InformationsquelleAutor iamantony

Solution pour diviser vecteur de la variable de comptage de pièces à l'aide d'itérateur.

#include <iostream>
#include <vector>

int main()
{
   //Original vector of data
   std::vector<double> mainVec{1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0};
   //Result vectors
   std::vector<std::vector<double>> subVecs{};
   //Start iterator
   auto itr = mainVec.begin();
   //Variable to control size of non divided elements
   unsigned fullSize = mainVec.size();
   //To regulate count of parts
   unsigned partsCount = 4U;
   for(unsigned i = 0; i < partsCount; ++i)
   {
       //Variable controls the size of a part
       auto partSize = fullSize / (partsCount - i);
       fullSize -= partSize;
       //
       subVecs.emplace_back(std::vector<double>{itr, itr+partSize});
       itr += partSize;
   }
   //Print out result
   for (const auto& elemOuter : subVecs)
   {
       std::cout << std::fixed;
       for (const auto& elemInner : elemOuter)
       {
           std::cout << elemInner << " ";
       }
       std::cout << "\n";
   }
}

InformationsquelleAutor R.Mazgutov

Vous devez vous connecter pour publier un commentaire.