T ListaEnc<T>::retiraEspecifico(const T& dado) { if (listaVazia()) throw ERROLISTAVAZIA; int pos = posicao(dado); return retiraDaPosicao(pos); }
T ListaEnc<T>::retiraEspecifico(const T& dado) { if (listaVazia()) { throw std::runtime_error("Lista Vazia"); } else { return retiraDaPosicao(posicao(dado)); } }
/* Inicializando restrições de movimento. */ void zeros(unsigned int *indexp, unsigned int *tams, Vertex *Mtz) { unsigned int *aux, x, y; aux = (unsigned int *) malloc(k*sizeof(int)); VUTIL rest = 1; /* Restringindo o ponto zero em cada dimensão. */ for (x=0; x<k; x++) { for (y=0; y<x; y++) aux[y] = 0; Mtz[posicao(aux,indexp)].restricao += rest; while (inclui(aux, tams, x)) Mtz[posicao(aux,indexp)].restricao += rest; rest *= 2; } free(aux); }
/** Verifica se a Lista contêm o elemento especificado. * @param dado O dado que será verificado a existência dentro da Lista. * @return um boolean que indica se a Lista contêm ou não o elemento especificado. */ bool contem(T dado) { try { posicao(dado); return true; } catch (std::exception& e) { return false; } }
bool ListaEnc<T>::contem(const T& dado) { try { posicao(dado); return true; } catch (int e) { return false; } }
/** * @brief Testa se o dado está na lista * * @param[in] dado Dado a ser testato * * @return true se o dado estiver na lista, senão, false */ bool contem(const T& dado) { try { posicao(dado); } catch (std::runtime_error& err) { return false; } return true; }
//comentário T retiraEspecifico(T dado) { if(listaVazia()) throw 20; int pos = posicao(dado); if (pos < 0) throw 20; return retiraDaPosicao(pos); }
void atualiza () { // Accel da Nave1 acelNave (); // Accel dos tiros acelTiros (); // Posicao Tiros posicao (); //Colisao dos tiros colisaoTiro(); }
/* * @brief Metodo para retirar um dado especifico da Lista * @details Verifica se a lista não está vazia, caso esteja retorna um throw. * Cria uma variavel auxiliar de inteiro chamada 'pos' e chama o metedo 'posicao' * para atribuir a posição no array 'dados[]' do elemento 'dado'. * Verifica se a variavel 'pos' tem um valor valido, ou seja maior que zero, caso * isso se confirme retorna o metodo 'retiraDaPosicao' e passa como parametro a variavel 'pos' */ T retiraEspecifico(T dado) { int pos; if (listaVazia()) { throw(ERROLISTAVAZIA); } else { pos = posicao(dado); if (pos < 0) { throw(ERROPOSICAO); } else { return (retiraDaPosicao(pos)); } } }
/** Retira um elemento da Lista, se este objeto existir dentro da Lista. * @see listaVazia() * @param dado A posição do dado a ser retirado. * @exception ExcecaoErroPosicao Exceção que indica que o dado enviado via argumento não existe dentro dessa Lista, logo não pode ser removido. * @exception ExcecaoListaVazia Exceção que indica que um dado não pode ser retirado, pois a lsita já está vazia. * @return o dado do tipo T que foi retirado. */ T retiraEspecifico(T dado) { int indice = posicao(dado); return retiraDaPosicao(indice); }
//Retira dado elemento int Lista::retirarEspecifico(const char* lancamento) { int pos = posicao(lancamento); if (pos < 0) return -1; return retirarDaPosicao(pos); }
/** * Método que retira um objeto específico da classe ElementoDeLista. * * Para isso ele utiliza o método retiraDaPosicao, levando a posição do dado recebido como parametro. Para maiores informações vide retiraDaPosicao(). * * @param elemento = objeto da classe ElementoDeLista que vai ser retirado da lista. * @return InfoLista = ponteiro para um objeto da classe InfoLista. */ InfoLista* CabecaDeLista::retiraEspecifico(ElementoDeLista *elemento) { return retiraDaPosicao(posicao(elemento)); }
T ListaCirc<T>::retiraEspecifico(const T& dado) { if (ListaEnc<T>::listaVazia()) { throw ExcecaoListaVazia(); } return retiraDaPosicao(posicao(dado) + 1); }
T Lista<T>::retiraEspecifico(T dado) { if(listaVazia()) { throw ExcecaoListaVazia(); } return retiraDaPosicao(posicao(dado)); }
/** * @brief Retira o dado que for igual ao dado de entrada * * @param[in] dado Dado a ser retirado * * @return O dado retirado */ T retiraEspecifico(const T& dado) { return retiraDaPosicao(posicao(dado)); }
/*! \return Retorna e retira um dado específico do tipo T (apaga elemento). \param dado eh o endereço do dado que será retirado do tipo T. */ T retiraEspecifico(const T& dado) { int pos; if (!((pos = posicao(dado))+1)) throw(20); return retiraDaPosicao(pos); }
/** Retira um objeto específico da Lista Encadeada. * Este método retira o primeiro objeto da Lista Encadeada que tem o mesmo valor do dado fornecido. * @see retiraDaPosicao(int pos) * @see posicao(int pos) * @return o objeto do tipo T que foi retirado da Lista. Retorna NULL caso esse objeto não exista. */ T retiraEspecifico(const T& dado) { int pos = posicao(dado); return retiraDaPosicao(pos + 1); }
bool contem(const T& dado){ return posicao(dado)!=-1; }
//Olha se o lançamento está contido bool Lista::contem(const char* lancamento) const { return posicao(lancamento) > 0; }