Program for å gjøre om fra tommer til cm?

[saboi]

The C++ Programming Language er et must for alle som skal programmere C++.

Det er bibelen.

Selv om den kan være litt vanskelig i begynnelsen går det fint an å lære seg C++ hvis du bare fortsetter å lese. Det er den eneste boka jeg har lest, og jeg kan hvertfall litt C++. Etterpå funker den glimrende som oppslagsverk også

[søppel]

int* a;

// blah

for(int i = a.begin(); i != a.end(); i++) //??

cout << *i << endl;

 

Nei, en iterator er ikke det samme som en peker.

 

* front_insert_iterator<C>

* front_inserter<C>(C&)

* back_insert_iterator<C>

* back_inserter<C>(C&)

* insert_iterator<C>

* inserter<C, XI>(C&, XI)

* reverse_iterator<RI>

 

etc... har ikke tid til å diskutere det her. (kom akkurat inn fra seiletur, og skal ut igjen og seile til sverige strax :] )

 

Edit:

Videre, se kap./del 4 her:

http://www.sgi.com/tech/stl/table_of_contents.html

 

Videre, bør moderaterene "tenke etter først". (Topic liksom ..)

Endret 27. juni 2004 av søppel

[saboi]

Hva er det du snakker om nå søppel?

 

Fatt at jeg aldri har sagt at pekere er iteratorer. Men zirener sa "iteratorer er jo kjekt å ha" når Fredrik90 spurte om hva som var vitsen med pekere. Da sa du:

 

Hm, pekere har ikke noe med iteratorer eller vektorer (begge fra "std-biblioteket") å gjøre.

 

 

Iteratorer hadde aldri funket hvis det ikke var pekere fordi det er bare et wrapper rundt en peker.

 

Godta det.

Endret 27. juni 2004 av saboi

[søppel]

Tydelig at du ikke forstår hva jeg snakker om, en iterator er ikke noe i seg selv; en iterator er en beskrivelse av et interface - så det som ligger bak kan være hva som helst. Det er "utvidbart"; generisk. ... jeg kan babble i timevis om dette.

 

Altså det trenger ikke å være pekere der; altså i bakhånd, eller wrappet.

 

Jeg kan paste noe kode her som illustrerer dette, om du ikke tror meg - eller kan jeg bruke tiden min på andre ting enn å forklare ting for deg?

 

(Jekk deg en øl og slapp av litt i stedet du ..)

 

Edit:

..og jeg driter i hva du eller andre har sagt.. det er det de tenkte som teller - og et utsagn som "iteratorer er jo kjekkt å ha" i sammenheng med spørsmålet "hva er vitsen med pekere?", vitner om at noen har tenkt feil.

 

Så føkk deg og alle andre som har rett til sine gale meninger.

Endret 27. juni 2004 av søppel

[saboi]

Jøsses. Nå snakker du deg bare lenger og lenger bort.

 

Videre, se kap./del 4 her:

http://www.sgi.com/tech/stl/table_of_contents.html

 

Skulle dette være et argument for deg? Her står det: "Iterators are a generalization of pointers: they are objects that point to other objects."

 

Så hvordan i helvete du kan si at pekere ikke har noe med iteratorer å gjøre skjønner jeg ikke. Men fortsett å lev i troen.

 

Altså det trenger ikke å være pekere der; altså i bakhånd, eller wrappet.

 

Jeg kan paste noe kode her som illustrerer dette, om du ikke tror meg - eller kan jeg bruke tiden min på andre ting enn å forklare ting for deg?

 

Ja. Jeg vil veldig gjerne at du paster en iterator klasse som ikke bruker pekere. Gjerne en som funker med STL. Det klarer du vel lett uten pointere. Hvordan kan du egentlig iterere gjennom en array uten å bruke en peker? Hensikten er vel med en iterator at den skal peke på neste element ved bruk av ++ -- osv. Hmm dette minner jo fryktelig om en ting. Nå husker jeg det. Pointere. char* a = array; while(++a) // iterate through array

 

Jeg bare legger til litt andre ting jeg fra http://www.sgi.com/tech/stl/table_of_contents.html som du sa at vi måtte lese på for å skjønne at en iterator ikke har noe med pekere å gjøre.

Skal vi se hva vi finner da..

Jo: "Pointers, for example, are iterators; the value type of int* is int. Its distance type is ptrdiff_t, because, if p1 and p2 are pointers, the expression p1 - p2 has type ptrdiff_t"

Har du sett på makan..

 

Men du gir deg vel ikke nå søppel? Du skal vel stå på krava og hevde bestemt at du ikke tok feil. Da er det bedre å komme med ting som "føkk dere a!" eller hva?

Det er vel et tegn på at du ikke har så mye bedre å legge til i denne diskusjonen og at du ergo tok feil.

Life is tough.

Endret 28. juni 2004 av saboi

[søppel]

#include <iostream>
#include <iterator>
#include <vector>

using namespace std;


template<class CONT>
class Iterator : public CONT::iterator {
public:
template<typename ITER>
Iterator(ITER i)
 	:CONT::iterator(i)
 {
} // constructor


/*
 Does not return a pointer or reference to the object;
 returns a copy of the object instead.
*/
typename CONT::value_type operator*()
{
 return(CONT::iterator::operator*()); 
} // operator*
}; // Iterator


int main()
{
vector<int> arr;

arr.push_back(1);
arr.push_back(2);
arr.push_back(3);

cout << "User defined iterator: " << endl;
for(Iterator<vector<int> > i = arr.begin(); i != arr.end(); i++) {
 cout << "Before: " << *i;;
 //*i = temp; // Not possible.
 cout << "  After: " << *i << endl;
}
cout << endl;


cout << "Standard vector<T>::iterator:" << endl;
for(vector<int>::iterator i = arr.begin(); i != arr.end(); i++) {
 cout << "Before: " << *i;;
 *i = 123;
 cout << "  After: " << *i << endl;
}

return(0);
} // main

 

Her er en iterator med samme syntax som den "vanlige" iteratoren, men med annerledes oppførsel.

Jeg resirkulerer interfacet ved å arve, men endrer (overloader) deler av det slik at den ikke returnerer en reference/peker til et objekt, men i stedet en kopi av objektet - eller elementet i containeren.

 

En iterator er en beskrivelse av et interface, så måten den er implementert på er opp til den som har skrevet biblioteket.

 

En iterator kunne også tatt en kopi av hele konteineren, og hatt denne "i seg" for så å delt ut elementer (referanser/pekere eller kopier) fra "seg selv", men jeg gidder ikke paste et slikt eksempel nå. (T elem1; T elem2; ..så ungår man array/pekere)

 

Kan jo ta en titt på hva B.S. har å si om saken:

"An iterator is not a general pointer."

(jupp, "not" var skrevet med kursiv skrift i boka)

 

Edit:

..fra side 550 av TCPL.

 

Edit2:

..kan sitere litt til, denne gangen om hva iteratorer er (kontra hva de ikke er):

"Iterators are the glue that holds containers and algorithms together. They provide an abstract view of data so that the writer of an algorithm need not be concerned with concrete details of a myriad of data structures. Conversely, the standard model of data access provided by iterators relieves containters from having to provide a more extensive set of access operations." .. "Iterators support an abstract model of data as a sequence of objects"

 

"Iterators are a generalization of pointers: they are objects that point to other objects."

m.a.o.:

Idéen "iterarator" er mer enn en peker. (men kan være bare det)

Idéen "mat" er mer enn et eple. (men kan være bare det)

 

Er da mat det samme som (bare) eple?

Er da (eller eventuellt "inneholder") iterator det samme som (bare) en peker?

 

Når vi snakker om "iterator" så mener man gjerne std::iterator, ikke int* eller MinType*. Iteratoren kunne returnert en reference/peker som vanlig, men at operator++ var overloadet slik at den hoppet over annenhvert element. Noe helt annet, som man ikke skal blande sammen. (Sjekk hvordan bøker er oppdelt; de nevner gjerne pekere lenge før std::iterator.)

 

Hvis du synes jeg har "jukset" med ex. jeg pastet ovenfor, så er det ikke umulig å tenke seg andre måter å gjøre ting på. Kunne pastet en kodesnutt der man ikke brukte arrayer (pekere ja) i det hele tatt:

 

T elem1;

T elem2;

T elem3; // ..etc.

 

..her kunne man gjordt noe fancy med f.eks. template-metaprogrammering og laget "kunstige" arrayer med en variabel størrelse på konteineren på den måten - dette har jeg ikke tid til nå. (Her måtte man så klart ha gjordt endringer i konteineren også, eventuellt i allocatoren. Disse tingene er nært knyttet sammen; dette med std::iterator "flyter" altså litt over i containere også.)

 

Edit3:

Noe slikt:

#include <iostream>

using namespace std;


class NullT {
}; // NullT


template<int size, typename T>
class Array {
public:
T data;
Array<size - 1, T> next;
}; // Array


template<typename T>
class Array<0, T> {
public:
T data;
NullT next;
}; // Array


int main()
{
Array<3, int> a_int;
a_int.data = 0;
a_int.next.data = 1;
a_int.next.next.data = 2;

cout << a_int.data << endl;
cout << a_int.next.data << endl;
cout << a_int.next.next.data << endl;

return(0);
} // main

 

Uansett er det høl i hue å begynne å snakke om iterator (altså std::iterator) når spørsmålet gjaldt dette med pekere. Ting er liksom enklere enn hva folk legger opp til her. En iterator er ikke, eller har ikke noe med pekere å gjøre. Om den implementeres v.h.a. en peker eller ikke er irrelevant (og mye avhengig av containeren egentlig), man skal ikke blande disse tingene.

 

Selv om C++ "har noe med språk å gjøre", kan man ikke si at "språk er kjekkt å ha" når det eneste resten av verden lurer på er "hva pekere er (godt for)". En liten del av et språk altså.

 

Her kan "språk" byttes ut med de forskjellige delene av C++-språket som blir brukt for å implementere iterators; f.eks. templates, template specialization, funksjoner og kanskje pekere (men igjen, ikke nødvendigvis, egentlig).

 

..men for all del - prøv å forklar noen som ikke vet hva pekere er, at "std:iterator (og aalt det som hører til), har noe med pekere å gjøre" før han/hun har lært dette med pekere (i isolasjon)..

 

(skrevet i hui og hast mye av dette)

Endret 28. juni 2004 av søppel

[søppel]

Her er ennå et eksempel, har ikke sett igjennom koden før jeg pastet den, men paster fordet:

 

#include <iostream>
#include <iterator>
#include <vector>

using namespace std;



template<class CONT>
class Iterator {
public:
Iterator(CONT cont)
 :current(0),
  _cont(cont)  
 {
} // constructor


typename CONT::Type operator*()
{
 return(_cont[current]);
} // operator*


bool operator!=(Iterator<CONT> other)
{
 return(other.current != (*this).current);
} // operator!=


typename CONT::Type operator++(int)
{
 current++;
 return(_cont[current]);
} // operator++


unsigned int current;


private:
CONT _cont; // Nada array nor pointers here.
}; // Iterator



template<typename T, int SIZE, template<class> class ITERATOR = Iterator>
class Container {
public:
typedef T Type;
typedef ITERATOR<Container> Iterator;
enum { Size = SIZE };


class NullT {
}; // NullT


template<int SIZE2, typename T2>
class Array {
public:
 typedef T2 Type;
 
 Array<SIZE2 - 1, T2> next;
 
 T data;
}; // Array

template<typename T2>
class Array<0, T2> {
public:
 typedef T2 Type;
 
 NullT next;
 
 T2 data;
}; // Array


Array<SIZE, T> data; // Nada array nor pointers here.


T operator[](unsigned int i)
{
 switch(i) {
 case 0:
 	return(data.data);
 	break;
 case 1:
 	return(data.next.data);
 	break;
 case 2:
 	return(data.next.next.data);
 	break;
 default:
 	return(T());
 	break;
 }
} // operator[]


Iterator begin()
{
 
 Iterator i(*this);
 i.current = 0;
 return(i);
} // begin


Iterator end()
{
 Iterator i(*this);
 i.current = 3;
 return(i);
} // end


void operator()(unsigned int i, T new_value)
{
 switch(i) {
 case 0:
 	data.data = new_value;
 	break;
 case 1:
 	data.next.data = new_value;
 	break;
 case 2:
 	data.next.next.data = new_value;
 	break;
 default:
 	cerr << "blah" << endl;
 	break;
 	//exit(1);
 }
 
} // operator()
}; // Container


int main()
{
Container<int, 3> arr;

arr(0, 0); // This way, we do not need to use pointers.
arr(1, 1);
arr(2, 2);

cout << "User defined iterator: " << endl;
for(Container<int, 3>::Iterator i = arr.begin(); i != arr.end(); i++) {
 cout << "Before: " << *i;
 cout << "  After: " << *i << endl;
}
cout << endl;

cout << arr[0] << endl; // No pointers or references used here either.
cout << arr[1] << endl;
cout << arr[2] << endl;

return(0);
} // main

Endret 28. juni 2004 av søppel

[saboi]

Gratulerer! Du har klart å lage 2 HELT ubrukelig iterator-klasser. La meg vise hvor ubrukelige de er.

class iterator {
public:
   iterator() { cout << "Dette er en helt ubrukelig iterator-klasse"; }
};

 

I det første forsøket har du jo bare arva fra std::iterator og brukt std::iterator::value_type istedetfor std::iterator::pointer som jo er helt teit siden du bruker std::iterator sin implementasjon. Og hvis du tror at std::iterator kopierer objekter overalt så tar du nok feil. Altså blir det brukt pointere i det lille eksempelet ditt.

Og i det siste eksempelet, HAHA, så har du jo faen meg prestert å lage en statisk array. Jeg mener, hva i HELVETE? char array[5]; int i = 5; // jeg trenger ikke iteratorer for jeg kan jo gjøre sånn her i stedet: for(j = 0; j != i; ++j) { cout << array[j]; } En iterator skal gå (iterere, peke) gjennom elementene. Ikke kopiere hvert jævla element som tilsier at du må ha en statisk array. Ditt andre eksempel hadde jo funket flott med 1000000 elementer. Det hadde tatt ca 4-5 år å skrive koden, og ca 10-20 år og utføre den.

 

yeah. you da man!

Endret 28. juni 2004 av saboi

[A_N_K]

Dette ble visst en opphetet diskusjon. Tør jeg foreslå at dere gjør opp i en omgang ut2k4 e.l? :]

[søppel]

Koden er ikke bra sånn den står nå - og jeg har aldri sagt at den er brukende til noe eller ikke, men den viser at man ikke trenger å bruke pekere for å få noe som er, eller ser ut som en "iterator".

 

Den siste koden (switch-opplegget, som "hadde tatt ca. 4-5 år å skrive") kunne muligens vært løst på samme måte som TypeAt i Loki.

( http://cvs.sourceforge.net/viewcvs.py/loki...t.h?view=markup )

 

Uansett, og igjen; iterators (std::iterator) er ikke, og har ikke noe med pekere å gjøre; man snakker om pekere - og man snakker om iteratorer.

[saboi]

Dette her gidder jeg ikke mer. Du skjønner godt hva zirener mente når han sa "iteratorer er kjekkt å ha" fordi pointere er helt nødvendig hvis du skal ha en iterator. Sånne drittkoder som du kommer med er bare utrolig idiotisk. Du kopierer jo bare for faen elementer.

[søppel]

- "Hva er vitsen med pekere?"

- "Iteratorer er jo kjekkt å ha."

 

Første jeg tenkte på er std::iterator, og std::iterator hører ikke hjemme i et svar på hva pekere er.

[saboi]

ok. dette er siste posten min her.

Dette kommer fra http://www.csci.csusb.edu/dick/c++std/cd2/lib-iterators.html som er en gammel version av c++-standarden (jeg har ikke tilgang til den nye men jeg tviler på at iterator-typen har endret seg så mye)

 

24.1 Iterator requirements [lib.iterator.requirements]

 

1 Iterators are a generalization of pointers that allow a C++ program to

work with different data structures (containers) in a uniform manner.

To be able to construct template algorithms that work correctly and

efficiently on different types of data structures, the library formal-

izes not just the interfaces but also the semantics and complexity

assumptions of iterators. All iterators i support the expression *i,

resulting in a value of some class, enumeration, or built-in type T,

called the value type of the iterator. All iterators i for which the

expression (*i).m is well-defined, support the expression i->m with

the same semantics as (*i).m. For every iterator type X for which

equality is defined, there is a corresponding signed integral type

called the difference type of the iterator.

 

2 Since iterators are an abstraction of pointers, their semantics is a

generalization of most of the semantics of pointers in C++. This

ensures that every template function that takes iterators works as

well with regular pointers. This Standard defines five categories of

iterators, according to the operations defined on them: input itera-

tors, output iterators, forward iterators, bidirectional iterators and

[Dead_Rabbit]

Et utsnitt fra "The C++ Programming Language, third edition":

For example, a vector`s iterator is most likely an ordinary pointer because a pointer is quite a reasonable way of referring to an element of a vector: (og så en illustrasjon)

 

Har ikke grundig lest gjennom de siste postene her men jeg syns da det virker som at ihvertfall noen typer iteratorer har noe med pekere a gjøre. Eller hva?

Dette med at en iterator har en del med pekere å gjøre var ikke noe jeg bare fant på.

[søppel]

Jerrå, og om en bil er ("is a", bare andre veien her) grønn, så har det noe med hvordan lys, farger, frekvenser og dine øyne og hjerne fungerer-å-gjøre.

 

Man begynner ikke å snakke om std::iterator når noen spør "hva en peker er". ("Hvilken farge er bilen?")

 

En iterator er ikke en peker. En (std::)iterator er en mer generell idé.

 

Om du/dere er (u)enige i dette er totalt irrelevant for meg.

Endret 7. juli 2004 av søppel

[Feynman]

Har ikke grundig lest gjennom de siste postene her men jeg syns da det virker som at ihvertfall noen typer iteratorer har noe med pekere a gjøre. Eller hva?

Dette med at en iterator har en del med pekere å gjøre var ikke noe jeg bare fant på.

Er vel mest enig med søppel i denne saken. Pekere brukes i en del iteratorer, men vær forsiktig med å sette likhetstegn. Iterator er et abstrakt begrep. Når en blander inn pekere begynner man å snakke om hvordan iteratoren implementeres.

 

Men det får vel være opp til hver enkelt hvor mye de gidder å henge seg opp i slike detaljer. Skal man bare programmere for sin egen del er det ikke så viktig. Hvis en jobber med programmering på avansert nivå bør en kanskje holde tungen beint i munnen. Jeg syns i hvert fall det er viktig å ikke blande epler og bananer når en snakker om programmeringskonsepter.

[Dead_Rabbit]

Jeg har ikke sagt at det er det samme(av det jeg kan huske ihvertfall), men noen iteratorer har en viss likhet med pekere, det står det jo i boka til Bjarne Stroustrup.

Det var også bare et eksempel at en peker kan brukes(ihvertfall nesten) som en iterator. Og hva er vitsen med å delta i et forum hvis man ikke er åpen for noe annet enn det man selv vet(tror man vet), da er det jo liten vits å diskutere i et forum. Og når vi snakker om biler her; selv om jeg sier at noe er en bil, så betyr ikke det at bilen må være grønn.

[A_N_K]

Ikke for å pirke, men det hele bunner ut i at en peker er en iterator. Det gjelder selvfølgelig ikke nødvendigvis andre veien.

[Feynman]

Ikke for å pirke, men det hele bunner ut i at en peker er en iterator. Det gjelder selvfølgelig ikke nødvendigvis andre veien.

Sjekket litt i C++-boken til Stroustrup. Og det kan virke som det stemmer ja. For C++.

 

Pekere er noe man finner i mange andre programmeringsspråk. Tror egenlig det som er viktig er å forstå hva pekere er (på lavt nivå) enn hva en iterator er (det er viktig, men kan læres senere).

[søppel]

Når vi først siterer her, så kan jeg slenge meg på og gjenta:

 

"An iterator is not a general pointer."

 

Ikke at jeg bryr meg så fryktelig mye om disse siteringene, for jeg vet det selv - fra før - at en iterator kan være/er mer enn en peker. En peker peker på et minneområde, mens en iterator på et element i en konteiner. Den ene tingen handler mer om maskinvare, den andre handler om noe mer abstrakt.

 

"Iterators are a generalization of pointers: they are objects that point to other objects."

 

Og hva er vitsen med å delta i et forum hvis man ikke er åpen for noe annet enn det man selv vet(tror man vet),

 

Jeg tror ikke - jeg vet. Det som ofte kan diskuteres er måten man fremstiller det man vet. Om min måte å se ting på, og kanskje dermed fremstille på, ikke stemmer med din - kan det sansynligvis aldri endres, mulig du synes jeg er fargeblind.

 

da er det jo liten vits å diskutere i et forum.

 

Det har du allerede sagt, og jeg har i grunn gjentatt meg selv flere ganger i denne tråden også. Kan generalisere; hva er vitsen med å eksistere?

 

Edit:

Det hender seff. at jeg sier "jeg tror".

 

Edit2:

Jeg kan jo si ting på en annen måte;

 

- "Jeg synes ikke pekere har noe som helst med iteratorere å gjøre."

- "Jeg synes ikke iteratorer har noe som helst med pekere å gjøre."

 

Så kan du/dere/Bjarne/hvemsomhelst si hva du/dere/de synes - og vi kan værra enige om at vi er uenige. Etc. :}

 

Edit3:

Denne posten er postet med forbehold om symptomer á "lillelørdag og grille-ute-effekt". Heh :]

Endret 7. juli 2004 av søppel