Cuestión : Ayudarme a entender porqué un código es mejor que el otro .....

El código #1 y el código #2 alcanza el mismo resultado.  Necesito la comprensión de la ayuda porqué una puede ser mejor que el other. class= > " claro " del
> del " codeSnippet " del class= del
class= " lineNumbers " del
class= del 
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:
>CODE notpretty #1 " del class= " del id= " codeSnippet835862 del 
 del #include
 del #include
 del #include
 del #include
 del #include
 del #include
 del #include

usar namespace std;

struct StudentAttempt
{
   distancia de la internacional;
   studentName de la secuencia;
};

cmpAttempts del bool (StudentAttempt dejado, la derecha de StudentAttempt) {
   si (left.distance < right.distance) {
      de vuelta verdad;
   }
   si (== right.distance de left.distance) {
      si (left.studentName < right.studentName) {
         de vuelta verdad;
      }
      
         falso de vuelta;
   }
   
      falso de vuelta;
}

bool isDistEqual (StudentAttempt dejado, la derecha de StudentAttempt) {
   volver (== right.distance de left.distance
      ¡&& left.studentName! = right.studentName);
}

size_t printAllEqual (vector& v, StudentAttempt& sa, stringstream& ss del const del const) {

   vector:: const_iterator i = v.begin ();
  size_t SZ = 0;
  el bFirst del bool = verdad;

  ¡mientras que (i! = v.end ()) {

    si (isDistEqual (*i, sa)) {
    
      ¡si (! bFirst) ss << “,”;
      ss << i->studentName;
      ++sz;
    }

    ++i; 
    bFirst = falso;
  }

  SZ de vuelta;
}
 

cañería de la internacional () {

   throwDist de StudentAttempt [] = {
      {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 manejado;

   internacional len = sizeof ()/sizeof (throwDist [0] del throwDist);
   dist del vector (el throwDist, throwDist + len);
   vector:: iterator él = dist.begin ();

   clase (dist.begin (), dist.end (), cmpAttempts);
   //unique (dist.begin (), dist.end (), cmpDist);


   para (; ¡él! = dist.end (); it++) {

      stringstream ss;

      pair:: iterator, bool> p = handled.insert (it->distance);

      ¡si (! p.second) continúan; // dirigido ya

      si (0 < printAllEqual (dist, *it, ss)) 
        cout << setw (2) << (*it) .distance 
           << “pies:  ” << (*it) .studentName << ss.str () << endl;
   }
}

CÓDIGO #2:
 del #include
 del #include
 del #include
 del #include
 del #include
 del #include
 del #include

usar namespace std;

struct StudentAttempt
{
   distancia de la internacional;
   studentName de la secuencia;
};

 cmpAttempts del bool (StudentAttempt dejado, la derecha de StudentAttempt) {
   si (left.distance < right.distance) 
   {
      de vuelta verdad;
   }
   si (== right.distance de left.distance) 
   {
      si (left.studentName < right.studentName) 
	  {
         de vuelta verdad;
      }
      
         falso de vuelta;
   }
   
      falso de vuelta;
}

cañería de la internacional () {

   throwDist de StudentAttempt [] = {
      {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 manejado;

   internacional len = sizeof ()/sizeof (throwDist [0] del throwDist);
   dist del vector (el throwDist, throwDist + len);
   vector:: iterator él = dist.begin ();

   clase (dist.begin (), dist.end (), cmpAttempts);
   //unique (dist.begin (), dist.end (), cmpDist);

   internacional x;
  para (x=0; x < dist.size (); x++) 
   {
      stringstream ss;
      pair:: iterator, bool> p = handled.insert (dist [x] .distance);
	  internacional z = 0;

      si (p.second)  
	  {
		  internacional y;

     	  para (y=0; y < dist.size (); y++) 
		  {
			  ¡si dist del && del dist del == (del dist [x] .distance [y] .distance [x] .studentName! = dist [y] .studentName)
				{
 					  ss << “,”;
					  ss << dist [y] .studentName;
					  z += 1;
				}
		  }
	 }
	si (z > 0)
	  {
	   cout << setw (2) << dist [x] .distance << “pies: ” << dist [x] .studentName << ss.str () << endl;
	   z = 0;
	  }
   }
}
class= del

Respuesta : Ayudarme a entender porqué un código es mejor que el otro .....

Para los iterators… Puede mirar no tan la primera vez, pero los iterators son una clase de más natural.  Cuando usted soluciona un problema, usted tiende a pensar en términos “procesa todos los elementos de…”, o matemáticamente “para todos los elementos en…”.  La única manera convencional de hacer que es utilizar un lazo.  El lazo del rato en idiomas de la C-familia es demasiado general; usted tiene hace algunos pasos en sus los propios.  Para el lazo en idiomas de la C-familia es una pequeña mejora sintáctica del rato.  En otros lenguajes de programación, para el lazo está un lazo contado.  Pero esto también significa que usted tiene que transformar un índice al elemento puesto en un índice.  Debido a ése, usted tiende a menudo a poner los elementos en un poco de estructura puesta en un índice -- a un arsenal o a un vector.

Si usted piensa más de él, cuál es una clase su realmente necesidad de lazo generalizado ese los lazos a través de todos los elementos de un envase sin necesario la preparación de un cierto índice numérico.  Si usted personifica el proceso, el trabajador dice otro “me da el siguiente”, y no “darme 3254o”.  Esto es exactamente para cuál son buenos los iterators.  El iterator es tipo-limita de alguna manera al envase.  Entonces usted puede estar no interesado en detalles internos (si está puesto en un índice adentro, o si es una estructura ligada).  Es decir los iterators traen más abstracción.

Desafortunadamente, los iterators son más nuevos que la base de C++ y por lo tanto allí no es ningún lazo y sintaxis generalizados para hacer todos de este más evidente sintácticamente.  Una vez que usted se acostumbra a un mejor sytax del lazo generalizado (en otras idiomas, como en el pitón donde los iterators trabajan casi mágico, ocultado), usted falta realmente ese sintaxis en C++.  El nuevo estándar de C++ va a mejorarlo un pedacito.
Otras soluciones  
 
programming4us programming4us