Pergunta : Ajudar-me a compreender porque um código é melhor do que o outro .....

O código #1 e o código #2 conseguem o mesmo resultado.  Eu preciso a compreensão da ajuda porque uma pode ser melhor do que o other. class= > " desobstruído " do
> do " codeSnippet " do class= do
class= " lineNumbers " do
class= do 
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 " do class= " do id= " codeSnippet835862 do 
 do #include
 do #include
 do #include
 do #include
 do #include
 do #include
 do #include

using namespace STD;

struct StudentAttempt
{
   distância do int;
   studentName da corda;
};

cmpAttempts do bool (StudentAttempt deixado, direita de StudentAttempt) {
   se (left.distance < right.distance) {
      do retorno retificar;
   }
   mais se (== right.distance de left.distance) {
      se (left.studentName < right.studentName) {
         do retorno retificar;
      }
      mais
         falso do retorno;
   }
   mais
      falso do retorno;
}

bool isDistEqual (StudentAttempt deixado, direita de StudentAttempt) {
   retornar (== right.distance de left.distance
      && left.studentName! = right.studentName);
}

size_t printAllEqual (vetor& v do const, StudentAttempt& sa do const, stringstream& ss) {

   vetor:: const_iterator i = v.begin ();
  size_t SZ = 0;
  o bFirst do bool = retifica;

  quando (i! = v.end ()) {

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

    ++i; 
    bFirst = falso;
  }

  SZ do retorno;
}
 

cano principal do int () {

   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 segurado;

   int len = sizeof) (do throwDist/sizeof (throwDist [0]);
   dist do vetor (o throwDist, throwDist + len);
   vetor:: iterator ele = dist.begin ();

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


   para (; ele! = dist.end (); it++) {

      stringstream ss;

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

      se (! p.second) continuam; // já segurado

      se (0 < printAllEqual (dist, *it, ss)) 
        cout << setw (2) << (*it) .distance 
           << “pés:  ” << (*it) .studentName << ss.str () << endl;
   }
}

CÓDIGO #2:
 do #include
 do #include
 do #include
 do #include
 do #include
 do #include
 do #include

using namespace STD;

struct StudentAttempt
{
   distância do int;
   studentName da corda;
};

 cmpAttempts do bool (StudentAttempt deixado, direita de StudentAttempt) {
   se (left.distance < right.distance) 
   {
      do retorno retificar;
   }
   mais se (== right.distance de left.distance) 
   {
      se (left.studentName < right.studentName) 
	  {
         do retorno retificar;
      }
      mais
         falso do retorno;
   }
   mais
      falso do retorno;
}

cano principal do int () {

   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 segurado;

   int len = sizeof) (do throwDist/sizeof (throwDist [0]);
   dist do vetor (o throwDist, throwDist + len);
   vetor:: iterator ele = dist.begin ();

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

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

      se (p.second)  
	  {
		  int y;

     	  para (y=0; y < dist.size (); y++) 
		  {
			  se (dist do && do dist do == do dist [x] .distance [y] .distance [x] .studentName! = dist [y] .studentName)
				{
 					  ss << “,”;
					  ss << dist [y] .studentName;
					  z += 1;
				}
		  }
	 }
	se (z > 0)
	  {
	   cout << setw (2) << dist [x] .distance << “pés: ” << dist [x] .studentName << ss.str () << endl;
	   z = 0;
	  }
   }
}
class= do

Resposta : Ajudar-me a compreender porque um código é melhor do que o outro .....

Para iterators… Pode olhar não assim em a primeira vez, mas os iterators são um tipo de mais natural.  Quando você resolve um problema, você tende a pensar nos termos “processa todos os elementos de…”, ou matematicamente “para todos os elementos em…”.  A única maneira convencional de fazer que é usar um laço.  O laço do quando em línguas da C-família for demasiado geral; você tem executa algumas etapas no seus próprios.  Para o laço em línguas da C-família é uma melhoria sintática pequena do quando.  Em outros linguagens de programação, para o laço está um laço contado.  Mas isto igualmente significa que você tem que transformar um índice ao elemento posicionado.  Por causa daquele, você tende frequentemente a põr os elementos em alguma estrutura posicionada -- a uma disposição ou a um vetor.

Se você pensa mais sobre ele, qual sua realmente necessidade é um tipo do laço generalizado esse laços através de todos os elementos de um recipiente sem necessariamente preparar algum índice numérico.  Se você personifica o processo, o trabalhador diz a um outro “dá-me seguinte”, e não “dar-me 3254th”.  Este é exatamente o que os iterators são bons para.  O iterator é tipo-limita de algum modo ao recipiente.  Então você pode estar nao interessado em detalhes internos (se está posicionado para dentro, ou se é uma estrutura lig).  Ou seja os iterators trazem mais abstração.

Infelizmente, os iterators são mais novos do que o núcleo de C++ e conseqüentemente lá não é nenhuns laço e sintaxe generalizados para fazer sintaticamente tudo deste mais aparente.  Uma vez que você se habitua ao melhor sytax do laço generalizado (em outras línguas, como no pitão onde os iterators trabalham quase màgica, escondido), você falta realmente essa sintaxe em C++.  O padrão novo de C++ está indo melhorá-lo um bocado.
Outras soluções  
 
programming4us programming4us