Fractionner le vecteur en plusieurs tableaux / vecteurs C ++

J'ai trouvé une fonction de fractionnement sur stackoverflow il y a quelque temps. Malheureusement, je ne peux plus poster le lien.

#include <string>
#include <vector>

class BasicVariant
{
private:
    std::string str;
public:
    BasicVariant(const std::string& _str) :str(_str) {}
    BasicVariant(int value) :str(std::to_string(value)) {}
    BasicVariant(double value) :str(std::to_string(value)) {}
    inline int toInt()const { return *this; }
    inline double toDouble()const { return *this; }
    inline std::string toString()const { return *this; }
    inline bool toBool()const { return toDouble(); }
    inline operator int()const { return std::stoi(str); }
    inline operator double()const { return std::stof(str); }
    inline operator std::string()const { return str; }
    inline operator bool()const { return toDouble(); }
};


template<typename T>
void split(const std::string& str, std::vector<T>& sink, const std::string& delims)
{
    std::size_t current, previous = 0;
    current = str.find_first_of(delims);
    while (current != std::string::npos)
    {
        sink.push_back(std::move(BasicVariant(str.substr(previous, current - previous))));
        previous = current + 1;
        current = str.find_first_of(delims, previous);
    }
    sink.push_back(std::move(BasicVariant(str.substr(previous, current - previous))));
}




int main()
{
    std::vector<std::string> vec{ "0 14 150","1 2 220" };
    std::vector<std::vector<int>> intVec(3, std::vector<int>(vec.size()));
    for (int i = 0; i < vec.size(); i++)
    {
        std::vector<int> row;
        split(vec[i], row, " ");
        for (int j = 0; j < row.size(); j++)
            intVec[j][i] = row[j];
    }

    system("pause");
}

J'aurai besoin d'un délimiteur dans vos chaînes (semble être un retour arrière dans votre cas) et appeler la fonction sur chaque élément de votre vecteur de chaîne: p>

int main()
{
std::vector<std::string> vec{ "0 14 150","1 2 220" };
std::vector<std::vector<int>> intVec(3,std::vector<int>(vec.size()));
for (int i = 0; i < vec.size(); i++)
{
    std::vector<std::string> singleStr;
    split(vec[i], singleStr, " ");
    for (int j=0; j < singleStr.size();j++)
        intVec[j][i] = (std::stoi(singleStr[j]));
}

system("pause");
}

Une solution plus générique pourrait ressembler à ceci. Vous pouvez ajouter d'autres types à BasicVariant

void split(const std::string & str, std::vector<std::string>& cont, const std::string & delims)
{
    std::size_t current, previous = 0;
    current = str.find_first_of(delims);
    while (current != std::string::npos) 
    {
        cont.push_back(std::move(str.substr(previous, current - previous)));
        previous = current + 1;
        current = str.find_first_of(delims, previous);
    }
    cont.push_back(std::move(str.substr(previous, current - previous)));
}

Modifier: J'ai supprimé une fonction de transposition détaillée.

Je suppose que vous voulez convertir std::vector<:string> en une matrice 2D std::vector<:vector>> . Par exemple, pour votre exemple, le résultat souhaité est supposé être arr1 = {0,1, ...} , arr2 = {14,2, ...} code > et arr3 = {150,220, ...} .

Premièrement,

• Nous pouvons utiliser std :: istream_iterator pour extraire les entiers des chaînes.

• Nous pouvons également appliquer le constructeur de plage pour créer un std::vector correspondant à chaque chaîne.

Donc, la fonction suivante fonctionnerait pour vous et cela ne me semble pas du moins être un code spaghetti . Tout d'abord, cette fonction extrait deux tableaux d'entiers {0,14,150, ...} et {1,2,220, ...} sous forme de matrices à partir d'un vecteur de chaîne passé v . Comme un std :: istream_iterator construit par défaut est un itérateur de fin de flux, chaque constructeur de plage lit chaque chaîne jusqu'à ce qu'il ne parvienne pas à lire la valeur suivante. Et enfin, une transposée est renvoyée:

std::vector<std::string> v(n);
v[0] = "0 14 150";
v[1] = "1 2 220";
...
v[n-1] = "...";

auto matrix = extractNumbers<int>(v);

Ensuite, vous pouvez extraire des entiers d'un vecteur chaîne comme suit:

DEMO

#include <vector>
#include <string>
#include <sstream>
#include <iterator>

template <typename T>
auto extractNumbers(const std::vector<std::string>& v)
{
    std::vector<std::vector<T>> extracted;
    extracted.reserve(v.size());

    for(auto& s : v)
    {
        std::stringstream ss(s);
        std::istream_iterator<T> begin(ss), end; //defaulted end-of-stream iterator.

        extracted.emplace_back(begin, end);
    }

    // this also validates following access to extracted[0].
    if(extracted.empty()){
        return extracted;
    }

    decltype(extracted) transposed(extracted[0].size());
    for(std::size_t i=0; i<transposed.size(); ++i){
        for(std::size_t j=0; j<extracted.size(); ++j){
            transposed.at(i).push_back(std::move(extracted.at(j).at(i)));
        }
    }

    return transposed;
}

où matrice [0] est arr1 , matrice [1] est arr2 , et ainsi de suite. Nous pouvons également en obtenir rapidement des pointeurs internes par auto arr1 = std :: move (matrix [0]); .

Nous avons ici quelques malentendus.
La sortie de mon programme doit avoir trois tableaux / vecteurs.

La sortie ressemble à:

arr1| arr1| arr3
0   | 14  | 150
1   |  2  | 220
2   |  4  | 130