Iterator std::vector / parzysty / nieparzysty

Witam,

Chciałbym roździelić jeden vector stringów na dwa.
Powiedzmy że mam:

std::vectorstd::string baza;
w środku jest np.
[0] 000
[1] 111
[2] 222
[3] 333
[4] 444
[5] 555

a chciałbym otrzymać z tego dwa vectory:

std::vectorstd::string new1
[0] 000
[2] 222
[4] 444

std::vectorstd::string new2
[1] 111
[3] 222
[5] 333

jak pobrać numer iteratora i wtedy użyć np. %2

Możesz przecież lecieć po indeksach

for (size_t i = 0; i < baza.size(); ++i)
    if (i % 2 == 0)
        new1.push_back(baza[i]);

hmm jeżeli jest to vektor stringów to raczej w ten sposób nie da rady,

chce zapisać wartości rzędów w jednym vectorze, natomiast drugie rzędy np. nieparzyste w innym wektorze

no według mnie to lecisz po indeksach, zamieniasz stringa na int czy co tam chcesz i jak to jest parzyste to dajesz do jednego a jak nie to do drugiego... powinno działać o ile dobrze zrozumiałem problem

std::vector<std::string> new1;
std::vector<std::string> new2;
std::vector<std::string>::iterator I;//Na iteratorach jest optymalniej
int i=0;
for (I=baza.begin(); I!=baza.end();I++)
{
    if (i % 2 == 0)
        new1.push_back(*I);
    else
        new2.push_back(*I);
    i++;
}

Cuś takie.
Nie sprawdzałem ale powinno działać. Czas ~ O(wielkość bazy)

Nie płakałbym tak nad tym ++i vs i++.

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

int main()
{
	int sum = 0;
	vector<int> w = {1,2,3,4,5,6,7};

	for (auto it = w.begin(); it != w.end(); it++)
		sum += *it;

	cout << sum;
}

C:\myprogs\cpp>gpp -v
Using built-in specs.
COLLECT_GCC=c:/dj/bin/gpp.exe
COLLECT_LTO_WRAPPER=c:/dj/bin/../libexec/gcc/djgpp/5.10/lto-wrapper.exe
Target: djgpp
Configured with: /gcc-5.10/configure djgpp --prefix=/dev/env/DJDIR --disable-werror --enable-languages=c,c++,fortran,obj
c,obj-c++ --enable-libquadmath-support --enable-lto
Thread model: single
gcc version 5.1.0 (GCC)

C:\myprogs\cpp>gpp it_pp.cpp -o it_pp.exe -s -O3 --std=gnu++14

C:\myprogs\cpp>gpp pp_it.cpp -o pp_it.exe -s -O3 --std=gnu++14

C:\myprogs\cpp>it_pp
28
C:\myprogs\cpp>pp_it
28
C:\myprogs\cpp>fc /b it_pp.exe pp_it.exe
Porównywanie plików it_pp.exe i PP_IT.EXE
FC: nie stwierdzono różnic

Natomiast Visual (2010) rzeczywiście generuje innego exeka, nawet z /Ox. Nie mam czasu się przyglądać.

chwila, @char nie napisał, że one muszą być po kolei... napisał, że chce rozdzielić wektor na 2 i w jednym mają być parzyste a w drugim parzyste... i to wektory stringów... do tego potrzeba atoi bo innaczej się nie da

według mnie to powinno tak być:

vector<string>zrudlo;
vector<string>parzyste;
vector<string>nieparzyste;
tutaj jakies zapisywanie do zrudlo jakiś stringow z liczba
for (int i=0; i<zrudlo.size(); i++)
{
    if (atoi(zrudlo[i].c_str())%2==0)
    {
        parzyste.push_back(zrudlo[i]);
    }
    else
    {
        nieparzyste.push_back(zrudlo[i]);
    }
} 

Hmmm, nie chce konwertowac vectora stringow - chce rozdzielic je numerami indexow

Czyli vector<string> xxxx:

xxx[0]
xxx[1]
xxx[2]
xxx[3]
xxx[4]

vector<string>a,b;

a - zawiera indexy 0, 2, 4
natomiast b - 1, 3

Mam takie liczby zapisane dokladnie w vectorze<string> :
nr.index
[0] 0.000000
[1] 0.000000
[2] 0.020000000000000000
[3] 0.000000
[4] 0.040000000000000001
[5] -0.64009000000000005
[6] 0.059999999999999998
[7] -1.273100
[8] 0.080000000000000002
[9] -1.889600
[10] 0.100000000000000010
[11] -2.486000
[12] 0.120000000000000000
[13] -3.052800
[14] 0.140000000000000010
[15] -3.583700
[16] 0.160000000000000000
[17] -4.071400
[18] 0.179999999999999990
[19] -4.511900
[20] 0.200000000000000010
[21] -4.679600
[22] 0.220000000000000000
[23] -4.847300
[24] 0.230000000000000010
[25] -4.931200
[26] 0.239999999999999990
[27] -5.015000
[28] 0.260000000000000010
[29] -5.271300
[30] 0.280000000000000030
[31] -5.542900
[32] 0.299999999999999990
[33] -5.828700

I chce je rozdzielic na dwa vectory <string>, za pomoca atoi to nie zadziala

**kt1117 ** & twonek dzięki slicznie ten kodzik działa ! Dzięki za pomoc wszystkim !

 std::vector<std::string> new1;
std::vector<std::string> new2;
std::vector<std::string>::iterator I;//Na iteratorach jest optymalniej
int i=0;
for (I=baza.begin(); I!=baza.end();I++)
{
    if (i % 2 == 0)
        new1.push_back(*I);
    else
        new2.push_back(*I);
    i++;
}