Fråga : Hjälp mig att förstå varför man kodifierar är bättre än annan .....,

Både kodifiera #1 och kodifiera #2 uppnår det samma resultatet.  Jag behöver hjälpöverenskommelse, varför en kan vara bättre, än other. > för

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:

" codeBody " " >CODE #1 för class= " för #include #include #include #include #include #include using namespace std; struct StudentAttempt { int distanserar; stränga studentName; }; boolcmpAttempts (lämnade StudentAttempt, högra StudentAttempt) { om (left.distance < right.distance) { återgångt true; } annars, om (left.distance-== right.distance) { om (left.studentName < right.studentName) { återgångt true; } annars återgångt falskt; } annars återgångt falskt; } isDistEqual bool (lämnade StudentAttempt, högra StudentAttempt) { gå tillbaka (left.distance-== right.distance && left.studentName! = right.studentName); } printAllEqual size_t (constvector& v, constStudentAttempt& sa, stringstream& ss) { vector:: const_iterator i = v.begin (); size_t sz = 0; boolbFirst = true; stunder (I! = v.end ()) { om (isDistEqual (*ien, sa)) { om (! bFirst) ss << ”,”; ss << i->studentName; ++sz; } ++i; bFirst = falskt; } återgång sz; } huvudsaklig int () { StudentAttempt throwDist [] = { {50, ”A”}, {22, ”A”}, {16, ”B”}, {44, ”C”}, {33, ”D”}, {34, ”E”}, {22, ”F”}, {21, ”G”}, {49, ”A”}, {5, ”B”}, {2, ”C”}, {22, ”A”}, {33, ”B”}, {22, ”C”}, {22, ”D”}, {44, ”E”}, }; set behandlade; int len = sizeof) (för throwDist/sizeof (throwDist [0]); vectordist (throwDisten, throwDist + len); vector:: iterator det = dist.begin (); sortera (dist.begin (), dist.end (), cmpAttempts); //unique (dist.begin (), dist.end (), cmpDist); för (; det! = dist.end (); it++) { stringstream ss; pair:: iterator bool> p = handled.insert (it->distance); om (! p.second) fortsätter; // behandlade redan om (0 < printAllEqual (disten, *it, ss)) cout << setw (2) << (*it) .distance << ”fot: ” << (*it) .studentName << ss.str () << endl; } } KODIFIERA #2: #include #include #include #include #include #include #include using namespace std; struct StudentAttempt { int distanserar; stränga studentName; }; boolcmpAttempts (lämnade StudentAttempt, högra StudentAttempt) { om (left.distance < right.distance) { återgångt true; } annars, om (left.distance-== right.distance) { om (left.studentName < right.studentName) { återgångt true; } annars återgångt falskt; } annars återgångt falskt; } huvudsaklig int () { StudentAttempt throwDist [] = { {50, ”A”}, {22, ”A”}, {16, ”B”}, {44, ”C”}, {33, ”D”}, {34, ”E”}, {22, ”F”}, {21, ”G”}, {49, ”A”}, {5, ”B”}, {2, ”C”}, {22, ”A”}, {33, ”B”}, {22, ”C”}, {22, ”D”}, {44, ”E”}, }; set behandlade; int len = sizeof) (för throwDist/sizeof (throwDist [0]); vectordist (throwDisten, throwDist + len); vector:: iterator det = dist.begin (); sortera (dist.begin (), dist.end (), cmpAttempts); //unique (dist.begin (), dist.end (), cmpDist); int x; för (x=0; x < dist.size (); x++) { stringstream ss; pair:: iterator bool> p = handled.insert (dist [x] .distance); int z = 0; om (p.second) { int y; för (y=0; y < dist.size (); y++) { om (för ==dist för dist [x] .distance dist för && [y] .distance [x] .studentName! = dist [y] .studentName) { ss << ”,”; ss << dist [y] .studentName; z += 1; } } } om (z > 0) { cout << setw (2) << dist [x] .distance << ”fot: ” << dist [x] .studentName << ss.str () << endl; z = 0; } } } " klar "

Svar : Hjälp mig att förstå varför man kodifierar är bättre än annan .....,

För iterators…, Den kan se inte så på den första tiden, men iterators är en sort av naturligare.  När du löser ett problem, du ansar till funderare benämner in ”bearbetar alla beståndsdelar från…”, eller matematiskt ”för alla beståndsdelar i…”.  Det enda konventionellt långt som ska göras, som är att använda en kretsa.  Stunderna kretsar i C-familj som språk är för allmänna; du har gör något kliver på ditt eget.  För kretsa i C-familj som språk är en liten syntactic förbättring av stunderna.  I andra programmera språk för kretsa är räknad kretsar.  Men detta också hjälpmedel att du måste att omforma ett index till den indexerade beståndsdelen.  På grund av det du ansar ofta för att sätta beståndsdelarna in i indexerat något strukturerar -- till en samling eller till en vektor.

Om du funderare mer om den, vad ditt behov är egentligen en sort av generaliserat, kretsar som kretsar till och med alla beståndsdelar av en behållare, utan nödvändigtvis att förbereda något numeriskt index.  Om du personify det processaa, arbetarnågot att säga till en annan ”ger mig det nästa”, och inte ”ge mig 3254.”.  Detta är exakt vad iterators är bra för.  Iteratoren är skriva-begränsar somehow till behållaren.  Därefter du kan inte intresseras i inre specificerar (det är huruvida indexerad insida, eller huruvida det är anknuten strukturerar).  Med andra ord iteratorsna kommer med mer abstraktion.

Tyvärr iteratorsna är nyare, än kärna ur av C++ och där är därför generaliserat inget kretsar och syntax för att göra alla av denna mer påtaglig syntactically.  Kretsa (i andra språk, något liknande i pytonormen, var iterators fungerar nästan magically som, när du får van vid bättre sytax av generaliserad döljas), dig missa egentligen den syntax i C++.  Den standarda nya C++en går att förbättra som den, a bet.