Iterators in C ++ (STL) vs Java, is daar 'n konseptuele verskil?

StackOverflow https://stackoverflow.com/questions/56347

  •  09-06-2019
  •  | 
  •  

Vra

Ek is terug te keer na c ++ nadat hy weg vir 'n bietjie en probeer om af te stof die ou waatlemoen.

In Java Iterator is 'n koppelvlak om 'n houer met metodes: hasNext () langs () en verwyder (). Die teenwoordigheid van hasNext () beteken dit het die konsep van 'n beperking vir die houer word gekruis. 

//with an Iterator
Iterator<String> iter = trees.iterator();
while (iter.hasNext()) 
{
    System.out.println(iter.next());
}

In die C ++ standaard sjabloon biblioteek, iterators lyk na 'n data type of klas die stutte die operateur ++ en operateur == verteenwoordig, maar het nie limietbegrip gebou in so vergelyking is nodig voordat die bevordering van die volgende item. Die limiet het om nagegaan deur die gebruiker vergelyking van twee iterators in die normale geval die tweede iterator is die houer einde. 

vector<int> vec;
vector<int>::iterator iter;

// Add some elements to vector
v.push_back(1);
v.push_back(4);
v.push_back(8);

for(iter= v.begin(); iter != v.end(); iter++)
{
    cout << *i << " "; //Should output 1 4 8
}

Die interessante deel is dat in C ++ 'n wyser is 'n iterator om 'n skikking. Die STL het wat bestaande en bou konvensie rondom dit.

Dit is daar enige verdere subtiliteit om dit wat ek mis?

Was dit nuttig?

Oplossing

Ja, daar is 'n groot konseptuele verskil. C ++ gebruik verskillende "klasse" van iterators. Sommige word gebruik vir ewetoeganklike (in teenstelling met Java), 'n paar word gebruik vir vorentoe toegang (soos Java). Terwyl selfs ander gebruik word vir die skryf van data (vir gebruik met, sê, transform).

Sien die iterators konsep in die C ++ Documentation :

  • Input Iterator
  • Uitgawe Iterator
  • Stuur Iterator
  • Bidirectional Iterator
  • Random Access Iterator

Dit is baie meer interessant en kragtige vergelyking met nietige iterators Java / C # 's. Hopelik sal hierdie konvensies word gekodifiseer met behulp van C ++ 0x se Konsepte .

Ander wenke

Miskien 'n bietjie meer teoretiese. Wiskundig kan versamelings in C ++ beskryf word as 'n half-oop interval van iterators, naamlik een iterator verwys na die begin van die versameling en een iterator wys net agter die laaste element.

Dit konvensie maak 'n gasheer van moontlikhede. Die manier waarop algoritmes werk in C ++, kan hulle almal toegepas word op deelstringe van 'n groter versameling. Om so 'n ding werk in Java te maak, moet jy 'n wrapper rondom 'n bestaande versameling wat 'n ander iterator terug te skep.

Nog 'n belangrike aspek van iterators reeds genoem deur Frank. Daar is verskillende konsepte van iterators. Java iterators ooreenstem met C ++ 'insette iterators, dit wil sê hulle lees net iterators dat slegs 'n stap kan geïnkrementeer op 'n tyd en kan nie agteruit gaan.

Aan die ander uiterste, jy C wenke wat presies ooreenstem met C ++ 'n konsep van 'n ewetoeganklike iterator.

Alles in ag genome, C ++ bied 'n veel ryker en suiwerder konsep wat aangewend kan word om 'n veel wyer verskeidenheid van take as óf C wysers of Java iterators.

Soos reeds genoem, Java en C # iterators beskryf 'n vermeng posisie (staat) -en-reeks (waarde), terwyl C ++ iterators skei die konsepte van posisie en verskeidenheid. C ++ iterators verteenwoordig 'waar ek nou' apart van 'waar kan ek gaan? ".

Java en C # iterators kan nie gekopieer word. Jy kan 'n vorige posisie nie herstel. Die algemene C ++ iterators kan.

Oorweeg hierdie voorbeeld : 

// for each element in vec
for(iter a = vec.begin(); a != vec.end(); ++a){
  // critical step!  We will revisit 'a' later.
  iter cur = a; 
  unsigned i = 0;
  // print 3 elements
  for(; cur != vec.end() && i < 3; ++cur, ++i){
      cout << *cur << " ";
  }
  cout << "\n";
}

Klik op die skakel hierbo om program uitset sien.

Dit eerder dom lus gaan deur 'n reeks (met behulp van vorentoe net iterator semantiek), die druk van elke aangrensende deelstring van 3 elemente presies een keer (en 'n paar korter deelstringe aan die einde). Maar gedink N elemente, en M elemente per lyn in plaas van 3, sal hierdie algoritme steeds inkremente O (N * M) iterator, en O (1) ruimte.

Die Java styl iterators gebrek aan die vermoë om posisie onafhanklik te stoor. Jy sal óf

  • verloor O (1) ruimte, met behulp van (byvoorbeeld) 'n skikking van grootte M om geskiedenis te stoor as jy Itereer
  • moet deurkruis die lys N tye, maak O (N ^ 2 + N * M) tyd
  • of gebruik 'n konkrete tipe Array met GetAt lid funksie, verloor genericism en die vermoë om gekoppel tipes lys houer gebruik.

Sedert net vorentoe iterasie meganika gebruik in hierdie voorbeeld, ek was in staat om te ruil in 'n lys met geen probleme . Dit is van kritieke belang om generiese algoritmes, soos soek, vertraag inisialisering en evaluering, sorteer authoring, ens.

Die onvermoë om staat te behou ooreenstem nouste aan die C ++ STL invoer iterator, waarop baie min algoritmes gebou.

'n wyser na 'n skikking element is inderdaad 'n iterator in die skikking.

As jy sê, in Java, 'n iterator het meer kennis van die onderliggende houer as in C ++. C ++ iterators is algemeen, en 'n pair van iterators kan enige reeks aan te dui: dit kan 'n sub-reeks 'n houer, 'n reeks oor verskeie houers wees (sien http://www.justsoftwaresolutions.co.uk/articles/pair_iterators.pdf of http://www.boost.org/doc/libs/1_36_0/libs/iterator/ doc / zip_iterator.html ) of selfs 'n reeks van getalle (sien http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/counting_iterator.html )

Die iterator kategorieë te identifiseer wat jy kan en nie kan doen nie met 'n gegewe iterator.

Vir my is die fundamentele verskil is dat Java Iterators punt tussen items, terwyl C ++ STL iterators wys op items.

C ++ iterators is 'n veralgemening van die wyser konsep; hulle maak dit van toepassing op 'n wye verskeidenheid situasies te. Dit beteken dat dit gebruik kan word om sulke dinge te doen as definieer arbitrêre reekse.

Java iterators is relatief dom opnemers (hoewel nie so erg soos C # 's, ten minste Java het ListIterator en kan gebruik word om die versameling muteer)

.

Iterators is net gelyk aan wysers in die triviale geval van iterating oor die inhoud van 'n skikking in volgorde. 'N iterator kan lewer voorwerpe uit 'n aantal ander bronne. Van 'n databasis, uit 'n lêer van die netwerk, uit 'n ander berekening, ens

C ++ biblioteek (die deel voorheen bekend as STL) iterators is ontwerp in ooreenstemming met verwysings na wees. Java, sonder wyser rekenkundige, het die vryheid om te wees meer programmeerder-vriendelike.

In C ++ jy eindig met 'n paar van iterators gebruik. In Java jy óf gebruik 'n iterator of 'n versameling. Iterators is veronderstel om die gom tussen algoritme en datastruktuur wees. Kode geskryf vir 1.5 + nodig selde noem iterators, tensy dit is die uitvoering van 'n spesifieke algoritme of datastruktuur (wat die verskil meerderheid van programmeerders het geen behoefte om dit te doen). As Java gaan vir 'n dinamiese polimorfisme deelversamelings en dies meer is veel makliker om te hanteer.

Daar is baie van die goeie antwoorde oor die verskille, maar ek het gevoel die ding wat my die meeste met Java iterators is nie beklemtoon sorg vir groot struikelblok - Jy kan nie lees die huidige waarde meer as een keer. Dit is regtig nuttig in baie scenario's, veral wanneer jy die samesmelting iterators.

In c ++, jy het 'n metode om die iterator bevorder en om die huidige waarde te lees. Lees die waarde daarvan nie vooraf die iterasie; sodat jy kan dit meer as een keer te lees. Dit is nie moontlik met Java iterators, en ek beland skep omhulsels wat dit doen.

'n kant nota: 'n maklike manier om 'n wrapper skep is om 'n bestaande een te gebruik - PeekingIterator uit Koejawel.

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top