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));
}
}
/**
NOME DA FUNÇÃO: retirarContato
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
É responsável por gerenciar as operações de remoção de contatos e delegá-las apropriadamente à lista e
informar se tudo aconteceu de maneira correta.
PARÂMETROS:
nenhum
VALOR DE RETORNO:
nenhum
CHAMA: exibeMenuSecundario, retira, retiraDoInicio, retiraDaPosicao, exibirMensagemErro
CHAMADA DE: main
*/
void retirarContato() {
int opcao, posicao, resultado;
exibeMenuSecundario("Remover do");
scanf("%d", &opcao);
switch (opcao) {
case 0:
resultado = retira();
break;
case 1:
resultado = retiraDoInicio();
break;
case 2:
puts("Forneça a posição a ser removida");
scanf("%d", &posicao);
resultado = retiraDaPosicao(posicao);
break;
default:
puts("Opção Inválida");
break;
}
if (resultado != 0)
exibirMensagemErro(resultado);
}
//comentário
T retiraEspecifico(T dado)
{
if(listaVazia())
throw 20;
int pos = posicao(dado);
if (pos < 0)
throw 20;
return retiraDaPosicao(pos);
}
T retiraEspecifico(const T& dado){
Elemento<T> *aux = head;
for (int j = 0; j < size; j++){
if(*aux->info== dado)
return retiraDaPosicao(j);
aux = aux->_next;
}
return;
}
/** 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 posicao;
if (!listaVazia()) {
posicao = this->posicao(dado);
if (posicao < 0) {
throw ExcecaoErroPosicao;
} else {
return retiraDaPosicao(posicao);
}
} else {
throw ExcecaoListaVazia;
}
}
/*
* @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 o último elemento da Lista.
* Este método retira o último elemento da Lista e decrementa o ponteiro da Lista.
* @see listaVazia()
* @exception ExcecaoListaVazia Exceção que indica que um dado não pode ser retirado, pois a lista já está vazia.
* @return o dado do tipo T que foi retirado do final da Lista.
*/
T retira() {
return retiraDaPosicao(ultimo);
}
//comentário
T retiraDoInicio()
{
if(listaVazia())
throw 20;
return retiraDaPosicao(0);
}
//comentário
T retira()
{
if(listaVazia())
throw 20;
return retiraDaPosicao(ultimo);
}
/**
NOME DA FUNÇÃO: retira
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
retira, se possível, um contato da última posição da lista. Ao final retorna o sucesso ou não da
operação.
PARÂMETROS:
nenhum
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
-- int 0 em caso de sucesso, código de erro em caso de problema
*/
int retira() {
return retiraDaPosicao(aLista.ultimo);
}
/** 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);
}
T ListaCirc<T>::retira() {
return retiraDaPosicao(this->tamanho);
}
int main(void){
ListaEnc *lista;
TipoInfo *info, *aux, *info2;
int escolha = -1;
char valor1[30];
char valor2[30];
int valor3 = -1000;
int pos = -1;
int flag = 0;
while ((escolha = menu())!= 0){
switch (escolha){
case 1:
flag++;
lista = criaLista(); break;
case 2:
valor3 = estah_vazia(lista);
system("clear");
if(valor3 == 1)
printf("A lista esta vazia\n");
else
printf("A lista nao esta vazia\n");
printf("\nObs: Quando a lista encadeada esta vazia, adicionar registro no fim\ne no inicio corresponde a uma mesma operacao.\n");
break;
case 3:
system("clear");
printf("Informe o nome do usuario: ");
scanf("%s", valor1);
printf("Informe o curso do usuario: ");
scanf("%s", valor2);
printf("Informe a fase em que se encontra o usuario: ");
scanf("%d", &valor3);
system("clear");
info = criaInfo(valor1, valor2, valor3);
adicionaNoInicio(lista, info); break;
case 4:
system("clear");
printf("Informe o nome do usuario: ");
scanf("%s", valor1);
printf("Informe o curso do usuario: ");
scanf("%s", valor2);
printf("Informe a fase em que se encontra o usuario: ");
scanf("%d", &valor3);
system("clear");
if(lista->tamanho > 1){
imprime_lista(lista);
do{
printf("Podera inserir registros entre o 1o e o ultimo registro inclusive");
printf("Informe a posicao que desejas inserir este registro: ");
scanf("%d", &pos); }while(pos <= 0 || pos >= lista->tamanho);
info = criaInfo(valor1, valor2, valor3);
adicionaNaPosicao(lista, info, pos);
}else if(lista->tamanho <= 1){
info = criaInfo(valor1, valor2, valor3);
adicionaNoInicio(lista, info);
}
break;
case 5:
adicionaEmOrdemNaPosicao(lista); break;
case 6:
system("clear");
printf("Informe o nome do usuario: ");
scanf("%s", valor1);
printf("Informe o curso do usuario: ");
scanf("%s", valor2);
printf("Informe a fase em que se encontra o usuario: ");
scanf("%d", &valor3);
system("clear");
info = criaInfo(valor1, valor2, valor3);
adicionaNoFim(lista, info); break;
case 7:
system("clear");
printf("Informe o nome do usuario: ");
scanf("%s", valor1);
printf("Informe o curso do usuario: ");
scanf("%s", valor2);
printf("Informe a fase em que se encontra o usuario: ");
scanf("%d", &valor3);
system("clear");
info2 = criaInfo(valor1, valor2, valor3);
pos = posicaoDoElemento(lista, info2);
if(pos == -1)
printf("Nao existe este registro\n");
else
printf("O registro existe e esta na posicao %d\n", pos);
destroiInfo(info2);
break;
case 8:
aux = retiraDoInicio(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase); break;
case 9:
system("clear");
if(lista->tamanho==0)
printf("Nao ha registros para serem retirados\n");
else if(lista->tamanho==1){
aux = retiraDoInicio(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase); break;
}else if(lista->tamanho==2){
imprime_lista(lista);
do{
printf("Podera inserir registros entre o 1o e o ultimo registro inclusive\n");
printf("Informe a posicao do registro que desejas remover: ");
scanf("%d", &pos); }while(pos <= 0 || pos >= lista->tamanho);
if(pos == 0){
aux = retiraDoInicio(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase);
}else{
aux = retiraDoFim(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase);
}
}else if(lista->tamanho>2)
imprime_lista(lista);
do{
printf("Podera inserir registros entre o 1o e o ultimo registro inclusive\n");
printf("Informe a posicao do registro que desejas remover: ");
scanf("%d", &pos); }while(pos <= 0 || pos >= lista->tamanho);
aux = retiraDaPosicao(lista, pos);
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase); break;
case 10:
aux = retiraDoFim(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase); break;
case 11:
imprime_lista(lista); break;
case 12:
if(flag == 1){
flag--;
destroi_lista(lista);
}else
printf("Nao ha lista para destruir\n");
}
}
if(flag == 1){
destroi_lista(lista);
}
return 0;
}
T retira(){
return retiraDaPosicao(size - 1);
}
/**
*Método que retira o último elemento da Lista.
*
* Para isso ele utiliza o método retiraDaPosicao, levando a última posição como parametro. Para maiores informações vide retiraDaPosicao().
*
* @return InfoLista = ponteiro para um objeto da classe InfoLista.
*/
InfoLista* CabecaDeLista::retira() {
return retiraDaPosicao(tamanho);
}
T Lista<T>::retira() {
return retiraDaPosicao(ultimo);
}
const ElementoGeometrico* ListaElementosGeometricos::retira(){
return retiraDaPosicao(size-1);
}
T Lista<T>::retiraDoInicio() {
return retiraDaPosicao(0);
}
T ListaEnc<T>::retira() {
return retiraDaPosicao(size-1);
}
T ListaCirc<T>::retiraEspecifico(const T& dado) {
if (ListaEnc<T>::listaVazia()) {
throw ExcecaoListaVazia();
}
return retiraDaPosicao(posicao(dado) + 1);
}
/** Retira o primeiro elemento da Lista.
* Este método retira o primeiro elemento da Lista e traz todos os dados uma posição para frente.
* @see listaVazia()
* @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 do início da Lista.
*/
T retiraDoInicio() {
return retiraDaPosicao(0);
}
/** 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 o último elemento da Lista.
* Este método retira o último elemento da lista circular simples.
* @see retiraDaPosicao(int pos)
* @return o dado do tipo T que foi retirado do final da Lista.
*/
T retira() {
return retiraDaPosicao(this->retornaTamanho());
}
/**
* @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));
}
T Lista<T>::retiraEspecifico(T dado) {
if(listaVazia()) {
throw ExcecaoListaVazia();
}
return retiraDaPosicao(posicao(dado));
}
/**
* 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));
}
/*
Retira um dado do fim da lista e elimina elemento.
*/
T retira() {
if (listaVazia())
throw(20);
return retiraDaPosicao(size-1);
}
/*!
\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);
}
T ListaEnc<T>::retira() {
return retiraDaPosicao(tamanho);
}
