C++ Lista::begin方法代码示例

vector<Persistivel*> PersisteMemoriaPessoa::carregarCadastros(const int id)
{
	vector<Persistivel*> vLista;

	Lista<Persistivel*>* lista = Sistema::getListaPessoas()->getLista();

	if (lista->tamanho() > 0)
	{
		Persistivel_local* persistivel_local = new Persistivel_local();
		Lista<Persistivel*>::Iterator it;
		it = lista->begin();

		while(it != lista->end())
		{
			persistivel_local = static_cast<Persistivel_local*>( *it );

			if (id > 0 && persistivel_local->getId() == id)
			{
				vLista.push_back( static_cast<Persistivel*>(persistivel_local) );
				return vLista;
			}
			else if (id < 0)
			{
				vLista.push_back(persistivel_local);
			}
			it++;
		}
	}
	return vLista;
}

void Bola::colidiu(Lista<Bloco> &blocos,Fila<Buff> &buffs,Player &jogador,Pilha<sf::Color> &pilha){
    for(Lista<Bloco>::iterator i=blocos.begin();i!=blocos.end();i++){
         if(this->getGlobalBounds().intersects(i->getGlobalBounds())){
             laser1.play();
             if(this->getPosition().y>i->getPosition().y&&this->getPosition().y<i->getPosition().y+25){
                 speed.x*=-1;
             }else speed.y*=-1;

             --(*i);
             //Olhar essa parte
             ///Mesmo sem quebrar o bloco, a pilha é alterada
             if(!pilha.empty()){
                 if(i->getFillColor()==pilha.top())
                     pilha.pop();
                 else
                     pilha.push(i->getFillColor());
             }
             if(i->getLife()==0){
                jogador.setPontos(jogador.getPontos()+10*i->getType());
                if(i->hasBuff){
                    if(!buffs.front().isActive){
                        buffs.front().isActive=true;
                        buffs.front().setPosition(i->getPosition());
                    }
                }
                i=blocos.erase(i);
             }

         }
    }
}

int main()
{
    int iPuntuacion = 0, iNumCorte = 0;
    string Entrada;

    Lista Jugadores;
    while( cin >> Entrada >> iPuntuacion ) {
        if( Entrada == "corte" ) {
            iNumCorte++;
            for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
                if( it->second.first < iPuntuacion && it->second.second == 0 ) {
                    it->second.second = iNumCorte;
                }
            }
        } else {
            if( iNumCorte == 0 ) {
                Jugadores[Entrada].first += iPuntuacion;
            } else {
                if( Jugadores.find( Entrada ) == Jugadores.end() ) {
                    cout << Entrada << "?" << endl;
                } else {
                    if( Jugadores[Entrada].second != 0 ) {
                        cout << Entrada << " OUT" << endl;
                    } else {
                        Jugadores[Entrada].first += iPuntuacion;
                    }
                }
            }
        }
    }

    vector<Pareja> Ordenar;
    for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
            Ordenar.push_back( Pareja(it->second.first, it->first) );
    }
    sort( Ordenar.begin(), Ordenar.end(), Comparar );

    for( int i = 0; i < int(Ordenar.size()); i++ ) {
        if( Jugadores[Ordenar[i].second].second == 0 )
            cout << "** " << Ordenar[i].second << " " << Ordenar[i].first << endl;
        else
            cout << "C" << Jugadores[Ordenar[i].second].second << " " << Ordenar[i].second << " " << Ordenar[i].first << endl;
    }

    return 0;
}

 vector<Par> MaxEmparejamiento() {
     fill(pareja.begin(), pareja.end(), -1);
     for (int i = 0; i < n; ++i) {
         if (!lado[i]) continue; CaminoIncremental(i);
         fill(visitado.begin(), visitado.end(), false);
     }
     vector<Par> pares;
     for (int i = 0; i < n; ++i)
         if (!lado[i] && pareja[i] != -1)
             pares.push_back(Par(pareja[i], i));
     return pares; // Cardinalidad = pares.size()
 }

 Flujo AumentarFlujo(int s, int t) {
     fill(padre.begin(), padre.end(), -1);
     queue<int> q; q.push(s); padre[s] = s;
     while (!q.empty()) {
         int u = q.front();
         q.pop(); if (u == t) break;
         for (int i = 0; i < aristas[u].size(); ++i) {
             int v = aristas[u][i];
             if (flujo[u][v] == cap[u][v] ||
                 padre[v] != -1) continue;
             padre[v] = u, q.push(v);
         }
     }
     if (padre[t] == -1) return 0;
     return ActualizarFlujo(t, FINF);
 }

	Flujo Dinic( int s, int t ){
		Flujo flujo_maximo = dist[t] = 0;
		while( dist[t] < INT_MAX){
			fill( dist.begin(), dist.end(), INT_MAX );
			queue<int> q; q.push(s); dist[s] = 0;
			while( !q.empty() ){
				int u = q.front(); q.pop();
				for( int i = 0; i < aristas[u].size(); i++ ){
					int v = aristas[u][i];
					if( flujo[u][v] == cap[u][v] || dist[v] <= dist[u] + 1 ) continue;
					dist[v] = dist[u] + 1, q.push(v);
				}
			}

			if( dist[t] < INT_MAX ) flujo_maximo += FlujoBloqueante( s, t, FINF );
		}
		return flujo_maximo;
	}

	Flujo Dinic( int s, int t ){
		Flujo flujo_maximo = dist[t] = 0;
		while( dist[t] < INT_MAX ){
			fill( dist.begin(), dist.end(), INT_MAX );
			queue<int> q; q.push(s); dist[s] = 0;
			while( !q.empty() ){
				int u = q.front(); q.pop();
				for( int i = 0; i < aristas[u].size(); i++ ){
					AristaFlujo* v = aristas[u][i];
					if( dist[v->dst] < INT_MAX )continue;
					if( v->flujo == v->cap )continue;
					dist[v->dst] = dist[u] + 1;
					q.push( v->dst );
				}
			}
			if( dist[t] < INT_MAX )
				flujo_maximo += FlujoBloqueante( s, t, FINF );
		}
		return flujo_maximo;
	}

int _tmain(int argc, _TCHAR* argv[])
{
	
	cout << "-------Probando con Int-------" << endl;
  Lista<int> numInt;
  for (int i = 0; i < 5; ++i) {
		numInt.insertarAlFrente(i);
		numInt.imprimir();	
	}
  numInt.eliminarDelMedio(2);
  numInt.imprimir();

  cout << "-------Iterador hacia Adelante-------" << endl;
  Iterador<int> it = numInt.begin();
  while (it != numInt.end()) {
	  cout << *it << endl;
	  ++it;
  }

  cout << "-------Iterador Inverso-------" << endl;
  IteradorInverso<int> it2 = numInt.rbegin();
  while (it2 != numInt.rend()) {
	  cout << *it2 << endl;
	  ++it2;
  }

  cout << "-------Probando con Double-------" << endl;
  Lista<double> numDou;
  for (int i = 0; i < 5; ++i) {
	  numDou.insertarAlFrente(i/2.22);
	  numDou.imprimir();
  }
  numDou.eliminarDelMedio(2);
  numDou.imprimir();

  cout << "-------Iterador hacia Adelante-------" << endl;
  Iterador<double> it3 = numDou.begin();
  while (it3 != numDou.end()) {
	  cout << *it3 << endl;
	  ++it3;
  }

  cout << "-------Iterador Inverso-------" << endl;
  IteradorInverso<double> it4 = numDou.rbegin();
  while (it4 != numDou.rend()) {
	  cout << *it4 << endl;
	  ++it4;
  }

  cout << "-------Probando con Char-------" << endl;
  Lista<char> numChar;
  for (char i = 'a'; i < 'a' + 5; ++i) {
	  numChar.insertarAlFrente(i);
	  numChar.imprimir();
  }
  numChar.eliminarDelMedio(2);
  numChar.imprimir();

  cout << "-------Iterador hacia Adelante-------" << endl;
  Iterador<char> it5 = numChar.begin();
  while (it5 != numChar.end()) {
	  cout << *it5 << endl;
	  ++it5;
  }

  cout << "-------Iterador Inverso-------" << endl;
  IteradorInverso<char> it6 = numChar.rbegin();
  while (it6 != numChar.rend()) {
	  cout << *it6 << endl;
	  ++it6;
  }

  cout << "-------Probando con Clase Persona-------" << endl;
  Lista<Persona> numPersona;
  Persona p1("Arbol", "1");
  Persona p2("Hoja", "2");
  Persona p3("Zeta", "3");

  numPersona.insertarAlFinal(p2);
  numPersona.imprimir();
  numPersona.insertarAlFinal(p1);
  numPersona.imprimir();
  numPersona.insertarAlFinal(p3);
  numPersona.imprimir();
  numPersona.insertarAlFinal(p3);
  numPersona.imprimir();
  numPersona.insertarAlFinal(p2);
  numPersona.imprimir();
  numPersona.insertarAlFinal(p1);
  numPersona.imprimir();

  numChar.eliminarDelMedio(2);
  numChar.imprimir();

  cout << "-------Iterador hacia Adelante-------" << endl;
  Iterador<Persona> it7 = numPersona.begin();
  while (it7 != numPersona.end()) {
	  cout << *it7 << endl;
	  ++it7;
  }
//.........这里部分代码省略.........

 vector<Par> EmparejamientoOptimo() {
     fill(pareja.begin(), pareja.end(), -1);
     fill(etiqueta.begin(), etiqueta.end(), 0);
     for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j)
         etiqueta[i] = max(etiqueta[i], costo[i][j]);
             
     for (int i = 0; i < n; ++i) {
         for (int j = 0; j < n; ++j)
             slack[j + n] = etiqueta[i] +
                 etiqueta[j + n] - costo[i][j];
         fill(visitado.begin(), visitado.end(), false);
         fill(retorno.begin(), retorno.end(), i);
         visitado[i] = true;
         
         bool emparejado = false;
         for (int j = 0; !emparejado; ++j) {
             int t = n; for (; t < 2 * n; ++t) {
                 if (visitado[t]) continue;
                 if (Igual(slack[t], 0)) break;
             }
             if (t < 2 * n) {
                 visitado[t] = true;
                 if (pareja[t] == -1) {
                     emparejado = true;
                     for (int p; ; t = p) {
                         pareja[t] = retorno[t];
                         p = pareja[retorno[t]];
                         pareja[retorno[t]] = t;
                         if (retorno[t] == i) break;
                     }
                 } else {
                     visitado[t = pareja[t]] = true;
                     for (int k = 0; k < n; ++k) {
                         Costo new_slack = etiqueta[t] +
                             etiqueta[k + n] - costo[t][k];
                         if (!Igual(new_slack, slack[k + n])
                             && new_slack < slack[k + n]) {
                             slack[k + n] = new_slack;
                             retorno[k + n] = t;
                         }
                     }
                 }
             } else {
                 Costo d = CINF;
                 for (int k = n; k < 2 * n; ++k)
                     if (!Igual(slack[k], 0))
                         d = min(d, slack[k]);
                 for (int k = 0; k < n; ++k)
                     if (visitado[k]) etiqueta[k] -= d;
                 for (int k = n; k < 2 * n; ++k)
                     if (!visitado[k]) slack[k] -= d;
                     else etiqueta[k] += d;
             }
         }
     }
     vector<Par> pares;
     for (int i = 0; i < n; ++i)
         if (!Igual(costo[i][pareja[i] - n], s * -CINF))
             pares.push_back(Par(i, pareja[i] - n));
     return pares; // Emparejamiento optimo.
 }