/**
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);
}
/**
* @brief Retira o dado na posição pos e o retorna
*
* @param[in] pos Posição para retirar
*
* @return O dado retirado
*/
T retiraDaPosicao(int pos) {
if(pos >= size || pos < 0)
throw std::runtime_error("posicao must be smaller than "
"ultimo+1 and greater than zero");
if (listaVazia())
throw std::runtime_error("lista vazia");
if (pos == 0)
return retiraDoInicio();
if (pos == size)
return retira();
auto e = head;
for (int i = 0; i < pos-1; ++i)
e = e->getProximo();
T dado = e->getProximo()->getInfo();
e->setProximo(e->getProximo()->getProximo());
--size;
return dado;
}
T ListaEnc<T>::retiraDaPosicao(int pos) {
if (listaVazia()) {
throw std::runtime_error("Lista Vazia");
} else {
if (pos > size-1 || pos < 0) {
throw std::runtime_error("Erro Posição");
} else {
if (pos == 0) {
return retiraDoInicio();
} else {
Elemento<T>* anterior = head;
Elemento<T>* eliminar;
for (int i = 0; i < pos-1; ++i) {
anterior = anterior->getProximo();
}
eliminar = anterior->getProximo();
anterior->setProximo(eliminar->getProximo());
--size;
T dado = eliminar->getInfo();
delete eliminar;
return dado;
}
}
}
}
/**
* Método que retira o elemento da lista que esta armazenado na posição recebida como parametro.
*
* Prara isso ele testa se a posicao recebida por parametro é válida, isto é, se existe algum objeto armazenado na mesma.
*
* @param posicao = inteiro que determina a localização do dado a ser retirado.
*
* @return 0(null) = Caso não seja possível retirar.
* @return InfoLista = ponteiro para um objeto da classe InfoLista.
*/
InfoLista* CabecaDeLista::retiraDaPosicao(int posicao) {
ElementoDeLista *anterior, *eliminar;
InfoLista *volta;
if (vazia()) {
std::cout << "Lista vazia." << std::endl;
return 0;
}
if (posicao > tamanho || posicao < 0) {
std::cout << "Posição inválida." << std::endl;
return 0;
} else {
if (posicao == 1) {
return retiraDoInicio();
} else {
anterior = primeiro;
for (int i = 0; i < posicao - 2; i++) {
anterior = anterior->proximo;
}
eliminar = anterior->proximo;
volta = eliminar->info;
anterior->proximo = eliminar->proximo;
tamanho--;
delete eliminar;
return volta;
}
}
}
/*!
\return Retorna o dado do tipo T da posição especificada.
\param pos eh a posicao do elemento cujo dado sera retirado da lista.
(elemento é apagado)
*/
T retiraDaPosicao(int pos) {
T dado;
Elemento<T> *ant, *sai;
if (pos >= size)
throw(20);
if (pos == 0)
return retiraDoInicio();
ant = head;
for (int controle = 0; controle < pos-1; controle++)
ant = ant->getProximo();
sai = ant->getProximo();
dado = sai->getInfo();
ant->setProximo(sai->getProximo());
size--;
return dado;
sai->~Elemento();
}
// Retira da lista o elemento que ocupa a posicao passada como paramêtro
T retiraDaPosicao(int pos) {
Elemento<T> *anterior, *eliminar;
T volta;
if (pos >= size)
throw 20;
if (pos == 0)
return retiraDoInicio();
anterior = head;
for (int i = 0; i < pos - 1; i++)
anterior = anterior->getProximo();
eliminar = anterior->getProximo();
volta = eliminar->getInfo();
anterior->setProximo(eliminar->getProximo());
size--;
delete eliminar;
return volta;
}
/**
* @brief Retira dado de uma posição espesifica
*
* @param[in] pos Posição do dado que vai ser removido
*
* @return Dado que foi removido
*/
T retiraDaPosicao(int pos) {
++pos;
if (listaVazia()) throw 20;
if (pos < 0 || pos > size) throw 20;
if (pos == 0) return retiraDoInicio();
if (pos == size) return retira();
auto current = head;
auto old = current;
while (--pos) {
old = current;
current = current->getProximo();
}
T retorno = current->getInfo();
old->setProximo(current->getProximo());
--size;
return retorno;
}
/** Retira um elemento de dentro da lista de acordo com a posição dada.
* Este método recebe um inteiro que indica a posição de um dado que se deseja retirar da Lista Encadeada.
* @param pos A posição do dado que se deseja retirar.
* @see retiraDoInicio()
* @see retornaAnterior(int pos)
* @return um objeto T que foi retirado da posição especificada. Retorna NULL se não conseguiu pegar um dado dessa posição.
*/
T retiraDaPosicao(int pos) {
T volta;
verificaPosicaoInvalida(pos);
if (pos == 0) {
retiraDoInicio();
} else {
Elemento<T> *anterior = head;
for (int i = 0; i < pos - 2; i++) {
anterior = anterior->getProximo();
}
Elemento<T> *eliminar = anterior->getProximo();
volta = eliminar->getInfo();
anterior->setProximo(eliminar->getProximo());
delete eliminar;
size--;
}
return volta;
}
T ListaCirc<T>::retiraDaPosicao(int pos) {
if (ListaEnc<T>::posicaoInvalida(pos)) {
throw ExcecaoPosicao();
}
if (pos == 0) {
return retiraDoInicio();
}
Elemento<T>* anterior = this->cabeca->getProximo();
for (int i = 1; i < pos - 1; i++) {
anterior = anterior->getProximo();
}
Elemento<T>* eliminar = anterior->getProximo();
T volta = eliminar->getInfo();
anterior->setProximo(eliminar->getProximo());
this->tamanho--;
delete eliminar;
return volta;
}
/** Retira um elemento de dentro da lista de acordo com a posição dada.
* Este método recebe um inteiro que indica a posição de um dado que se deseja retirar da lista circular simples.
* @param pos A posição do dado que se deseja retirar.
* @see retiraDoInicio()
* @see retornaAnterior(int pos)
* @return um objeto T que foi retirado da posição especificada. Retorna NULL se não conseguiu pegar um dado dessa posição.
*/
T retiraDaPosicao(int pos) {
T volta;
this->verificaPosicaoInvalida(pos);
if (pos == 0) {
retiraDoInicio();// return;
} else {
Elemento<T> *anterior = sentinel->getProximo();
for (int i = 0; i < pos - 2; i++) {
anterior = anterior->getProximo();
}
Elemento<T> *eliminar = anterior->getProximo();
volta = eliminar->getInfo();
anterior->setProximo(eliminar->getProximo());
delete eliminar;
this->defineTamanho(this->retornaTamanho() - 1);
}
return volta;
}
T ListaEnc<T>::retiraDaPosicao(int posicao) {
if (posicaoInvalida(posicao)) {
throw ExcecaoPosicao();
}
if (posicao == 0) {
return retiraDoInicio();
}
Elemento<T>* anterior = cabeca;
for (int i = 0; i < posicao - 2; i++) {
anterior = anterior->getProximo();
}
Elemento<T>* eliminar = anterior->getProximo();
T volta = eliminar->getInfo();
anterior->setProximo(eliminar->getProximo());
tamanho--;
delete eliminar;
return volta;
}
T retiraDaPosicao(int pos){
if (pos >= size || pos < 0)
throw std::runtime_error("Posição inválida");
Elemento<T> *aux, *eliminar;
T retorno;
if (pos == 0)
return retiraDoInicio();
aux = head;
for (int i = 0; i < pos-1; i++)
aux = aux->_next;
eliminar = aux->_next;
retorno = *aux->info;
aux->_next = eliminar;
size--;
delete eliminar;
return retorno;
}
/**
* @brief Retira o dado no final da lista e o retorna
*
* @return O dado retirado
*/
T retira() {
if (listaVazia())
throw std::runtime_error("lista vazia");
if (size == 1)
return retiraDoInicio();
auto e = head;
for (; e->getProximo()->getProximo(); e = e->getProximo()) {}
// T data = e->getInfo();
T data = e->getProximo()->getInfo();
e->setProximo(nullptr);
--size;
return data;
}
T ListaEnc<T>::retiraDaPosicao(int pos) {
if (listaVazia())
throw ERROLISTAVAZIA;
if (pos > (size - 1))
throw ERROPOSICAO;
if (pos == 0)
return retiraDoInicio();
Elemento<T> *walkingDead = head;
Elemento<T> *anterior;
for (int i = 0; i < pos; ++i) {
anterior = walkingDead;
walkingDead = walkingDead->getProximo();
}
anterior->setProximo(walkingDead->getProximo());
T retorno = walkingDead->getInfo();
delete (walkingDead);
size--;
return retorno;
}
TipoInfo *retiraDoFim(ListaEnc *lista){
int i;
if(estah_vazia(lista))
return NULL;
else{
if(lista->tamanho == 1)
return retiraDoInicio(lista);
else{
Elemento *aux = lista->cabeca;
for(i=0; i < lista->tamanho-2; i++)
aux = aux->proximo;
Elemento *e = aux->proximo;
TipoInfo *info = e->info;
aux->proximo = NULL;
lista->tamanho--;
free(e);
return info;
}
}
system("clear");
}
/**
* @brief Retira um elemento de uma posição deseja e retorna seu dado
*
* @param Posição do elemento a ser retirado
*
* @details Caso a posição seja 0, chama o metódo retiraDoInicio(), pois
* é um caso específico
*/
T retiraDaPosicao(int pos) {
if(listaVazia()) {
throw std::runtime_error("Lista Vazia");
}
if(pos > size-1 || pos < 0) {
throw std::runtime_error("Posição Inválida");
} else {
if(pos == 0) {
return retiraDoInicio();
} else {
Elemento<T> *anterior = head;
Elemento<T> *eliminar;
for(int i = 0; i < (pos-1); i++) {
anterior = anterior->getProximo();
}
eliminar = anterior->getProximo();
T volta = eliminar->getInfo();
anterior->setProximo(eliminar->getProximo());
delete eliminar;
--size;
return volta;
}
}
}
TipoInfo *retiraDoFim(ListaEnc *lista){
int i;
if(estah_vazia(lista))
return NULL;
else{
if(lista->tamanho == 1)
return retiraDoInicio(lista);
else{
Elemento *aux = lista->cabeca;
for(i=0; i < lista->tamanho-2; i++)
aux = aux->proximo;
printf("%s %s %d\n", aux->info->nome, aux->info->curso, aux->info->fase);
//Elemento *e = aux->proximo;
//TipoInfo *info = e->info;
//aux->proximo = NULL;
//lista->tamanho--;
//free(e);
//return info;
}
}
system("clear");
}
int main(void){
ListaEnc *lista;
TipoInfo *info, *aux;
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\n");
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:
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 6:
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 7:
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 8:
imprime_lista(lista); break;
case 9:
if(flag == 1){
flag--;
destroi_lista(lista);
}else
printf("Nao ha lista para destruir\n");
}
}
if(flag == 1){
destroi_lista(lista);
}
return 0;
}
/** Elimina um elemento no começo da Lista Encadeada.
* Este método elimina o primeiro elemento da Lista Encadeada, ou seja, destrói o objeto sem retornar qualquer valor.
* Chama o método "retiraDoInicio()" e caso este método retorne um objeto T, apaga esse objeto da memória.
* @see retiraDoInicio()
* @exception ExcecaoListaVazia Exceção que indica que o dado não pode ser eliminado pois a lista está vazia.
*/
void eliminaDoInicio() {
T elemento = retiraDoInicio();
delete elemento->getInfo();
delete elemento;
}