Deletar Vetor

albertoammar · 17 de outubro de 2013

Estava criando um vector de uma classe assim:

std::Vector<Myclass> elemento;

É o seguinte eu toda vezes que chamo uma função ela cria mais um elemento:

elemento.resize(elemento.size()+1)

Eu gostaria que toda vez que ela cria-se uma nova, ele deleta-se outras anteriores, ai dei uma pesquisada e vi que tem como fazer isso com .erase, mas ai que vem a duvida ela realmente limpa? Se eu continuar criando esses elemento até 1000 e sempre apagar o anterior, não irá ficar usando espaço na memoria?

fabianomf1974 · 17 de outubro de 2013

Será que você precisa de um vetor mesmo? Por que apagar os elementos anteriores? Se você não precisa dos anteriores então, a princípio, você não precisa de um vetor.

Você pode usar o método Erase para remover elementos do vetor, mas o método Resize irá recria-los, com a diferença que os elementos de índice menor que o atual que você está criando ficarão vazios, já que você removerá os elementos do tal vetor antes de redimensiona-lo.

Sim, quanto mais elementos, mais memória necessária para guardar o vetor, mesmo que ele cresça apenas na estrutura, sem dados em seus elementos. Se você preencher os elementos com dados será necessário ainda mais memória.

Quando você faz:

Elemento.Resize( Elemento.Size() + 1 )

Você está incrementando o seu vetor em um elemento, mas se você excluir os elementos do seu vetor antes do Resize, você continuará a ter um vetor de uma posição apenas. Por esse prisma, por que você precisa de um vetor da sua classe em vez de uma simples instância?

albertoammar · 17 de outubro de 2013

é o seguinte, eu tenho um classe que cria uma imagem que a leva para cima abaixando sua opacidade devagar até ficar invisivel. Só que eu posso criar varias ao mesmo instante, assim sendo pode existe um tempo que 15 vetores está rodando, como pode existir só 1.

Se eu limpo ela, teria como eu passar o ultimo para esse limpo, certo?

fabianomf1974 · 17 de outubro de 2013

Certo, mas eu ainda não entendi porque você quer remover posições do vetor. Como você tem a certeza que todas as instâncias nas posições anteriores já finalizaram o efeito da transparência?

Exemplo:

Elemento[ 0 ] = ClasseTransparencia (em 40%)

Elemento[ 1 ] = ClasseTransparencia (iniciando)

Nesse exemplo, se você excluir o Elemento[ 0 ] no momento da criação do Elemento[ 1 ], você vai finalizar a instância da ClasseTransparencia do Elemento[ 0 ] antes da conclusão do efeito de transparência dessa instância, uma vez que nesse exemplo o efeito encontra-se em 40% concluído.

O que me parece é que seria mais fácil e eficiente usar uma coleção em vez de um vetor, apesar das coleções serem mais dispendiosas em relação a vetores (mais memória, mais lentas, etc). Eu também tenho preferência em usar vetores, mas há casos em que elas são a solução.

Dê uma exemplificada no seu projeto para eu entender melhor o que você precisa, por favor.

Matheus Maldi · 17 de outubro de 2013

#include <iostream>
#include <vector>

void run()
{
	std::vector<int> vetor(1000000);
	for (size_t i = 0; i < vetor.capacity(); i++)
	{
		vetor[i] = i;
	}
	std::cout << vetor[999999];

	getchar();
}

void run2()
{
	std::vector<int*> vetor(100000);
	for (size_t i = 0; i < vetor.capacity(); i++)
	{
		vetor[i] = new int[1];
		vetor[i][0] = i;
	}
	std::cout << &vetor[999999];

	getchar();
}


int main()
{
	run();
	getchar();
	run2();

	getchar();
}

Abra o TaskManager, compile o programa.

note que ele terá um pouco mais de 4000k de ram em uso, isso é referente ao vetor criado no metodo run.

aperte alguma tela, o metodo run acaba e volta para o primeiro getchar do metodo main, veja que agora o programa usa poucos k de ram pois todos os elementos do vetor foram deletados.

aperte outra tecla, o programa vai subir a memoria de novo porém agora com alocação dinamica.

aperte outra tecla, neste momento o programa vai para o segundo getchar do metodo main, o vetor não deleta os inteiros criados dinamicamente, e só será deletado quando encerrar o programa.

Plástico Bolha · 18 de outubro de 2013

Cara com essas características que você deseja como remover e inserir de maneira dinâmica !!! O que você realmente procura então é uma "LISTA".

Para você sair das funções que eu fiz basta digitar um número negativo qualquer como -1.

Não sei se você conhece o conceito de lista mas basicamente é uma estrutura aonde você pode adicionar dados ou remover dados da posição que você quiser dinamicamente ou seja, o dado que você insere nela "É CRIADO NA HORA" em tempo de execução não em tempo de compilação, e o dado que você remove é também removido em tempo de execução da memória Até !

#include <stdio.h>
#include <stdlib.h>

typedef struct NO{
    NO* prox;
    float dado;
}NO;

typedef struct listaL{
    NO* primeiro;
    NO* ULT;
}listaL;

listaL *crial(){
    listaL *l = (listaL*) malloc(sizeof(listaL));
	l->primeiro = NULL;
	l->ULT = NULL;
    return l;
}

void insereP(listaL *l){
	printf("\nInsere Primeiro\n\n");
	float dado;
	do{
		printf("Digite o dado: ");
		scanf("%f", &dado);
		if(dado < 0) break;
		 NO *p=(NO*) malloc(sizeof(NO));
		 p->prox =  l->primeiro;
		 l->primeiro = p;
		 p->dado = dado;
		if(l->ULT == NULL){
			l->ULT = p;
		}
		else{
			NO* j;
			NO *aux;
			j = l->primeiro;
			while(j != NULL){
				aux = j;
				j = j->prox;
			}
			j = aux;
			l->ULT = j;
		}
	}while(dado >= 0);
	return;
 }

void imprime(listaL *l){
	NO* j;
	j = l->primeiro;
	printf("\n\nImprimir\n\n");
	while(j != NULL){
		printf("Elemento da lista: %.0f\n\n", j->dado);
		j = j->prox;
	}
}

int insereD(NO* x, NO* R, int dado){ 
	R->prox = x->prox;   
	x->prox=R;
	R->dado = dado;
	return 0;
}


int insereU(listaL *l){ 
	float dado;
	printf("\nInsere Ultimo\n\n");
	do{
	printf("Digite o dado: ");
	scanf("%f", &dado);
	if(dado < 0) break;
    NO* R=(NO*) malloc(sizeof(NO));

	if(l->primeiro == NULL){
			R->prox =NULL;
			l->ULT = R;
			l->primeiro = R;
			R->dado = dado;
		}
	else{
		NO* j;
		NO *aux;
		j = l->primeiro;
		while(j != NULL){
			aux = j;
			j = j->prox;
		}
		j = aux;
		j->prox = R;
		R->dado = dado;
		R->prox = NULL;
		l->ULT = R;
	}
	}while(dado >= 0);
	return 0;
}


void insereO(listaL *l){
	printf("\nInsere Ordenado\n\n");
	float dado;
	do{
		printf("Digite o dado: ");
		scanf("%f", &dado);
		if(dado < 0) break;

		if(l->primeiro == NULL){ 
				NO* R=(NO*) malloc(sizeof(NO));
				R->prox =NULL;
				l->ULT = R;
				l->primeiro = R;
				R->dado = dado;
		}
		else{
				int flag = 0;
				NO* R=(NO*) malloc(sizeof(NO));
				NO* j;
				NO *aux;
				j = l->primeiro;
				aux = j;
				while(j != NULL){
					if(dado > aux->dado){
						insereD(aux, R, dado);
						printf("\nO dado  %2.f foi adicionado\n\n", dado);
						flag = -1;
						break;
					}
					aux = j;
					j = j->prox;
				}
				if(flag == 0){
					if(dado > aux->dado){
						insereD(aux, R, dado);
						printf("\nO dado  %2.f foi adicionado\n\n", dado);
					}

				}
		}

	}while(dado >= 0);
	NO* j;
	NO *aux;
	j = l->primeiro;
	while(j != NULL){
			aux = j;
			j = j->prox;
	}
	j = aux;
	l->ULT = j;
	return;
 }

bool Vazia(listaL *l) { 
    if (l->primeiro == NULL)
        return true;
    else
		return false;
}

int RemoveP(listaL *l){
	int escolha;
	printf("\nRemover Primeiro\n\n");
	printf("Digite 1 para remover e -1 para sair\n");   

	while(1){
		printf("\n\nEscolha uma opção: ");
		scanf("%d", &escolha);
		if(escolha == 1){
			if(!Vazia(l)) {
				NO* x = l->primeiro;
				l->primeiro = l->primeiro->prox; 
				printf("\nO dado %2.f foi removido\n", x->dado);
				free(x);
			}
			else{
				printf("\nLista Vazia !!!\n");
				break;
			}

		}
		else if(escolha == -1){
			break;
		}
		else{
			printf("\nEscolha outro numero\n");
			continue;
		}
	}
	return 0;
}

int RemoveU(listaL* l){
	int escolha;
	printf("\nRemover Ultimo\n\n");
	printf("Digite 1 para remover e -1 para sair\n"); 
	while(1){
	printf("\n\nEscolha uma opção: ");
	scanf("%d", &escolha);

	if(escolha == 1){
		if(!Vazia(l)){
			int flag = 0;
			NO* j;
			NO *aux;
			j = l->primeiro;
			aux = j;
			while(j->prox != NULL){
				flag = -1;
				aux = j;
				j = j->prox;
			}
			j = aux;
			if(flag == -1){
				printf("\nO dado %2.f foi removido\n", j->prox->dado);
				j->prox=NULL;
				free(j->prox);
			}
			else if(flag == 0){printf("\nO dado %2.f foi removido\n", l->primeiro->dado);  free(l->primeiro->prox); l->primeiro = NULL;}
			}
			else{
				printf("\nLista Vazia !!!\n");
				break;
			}
	}
	else if(escolha == -1){
		break;
	}
	else{
		printf("\nEscolha outro numero\n");
		continue;
	}

	}
	NO* j;
	NO *aux;
	j = l->primeiro;
	aux = l->primeiro;
	while(j != NULL){
			aux = j;
			j = j->prox;
	}
	j = aux;
	l->ULT = j;
	return 0;

}

float RetornaU(listaL* l){
	if(l->ULT == NULL) return NULL;
	return l->ULT->dado;
}

int main(){
      listaL *l = crial();

	  int escolha = 1;
	  printf("OBS: Para sair das funcoes digite um numero negativo !!!\n\n");
	  while (escolha != 8){

	printf("\n\n ----------------------- ");

	printf("\n 1 - Inserir Primeiro ");
	printf("\n 2 - Inserir Ultimo ");
	printf("\n 3 - Inserir Ordenado ");
	printf("\n 4 - Remover Primeiro ");
	printf("\n 5 - Remover Ultimo ");
	printf("\n 6 - Retornar Ultimo ");
	printf("\n 7 - Imprimir ");
	printf("\n 8 - Sair ");
	printf("\n\n Escolha uma opcaoo: ");
	scanf("%d", &escolha);


	switch (escolha) {
	case 1:
		{
			insereP(l);
			printf("\n\n");
			break;
		}
	case 2:
		{
			insereU(l);
			printf("\n\n");
			break;
		}
	case 3:
		{
			insereO(l);
			printf("\n\n");
			break;
		}
	case 4:
		{
			RemoveP(l);
			printf("\n\n");
			break;
		}
	case 5:
		{
			RemoveU(l);
			printf("\n\n");
			break;
		}
	case 6:
		{
			printf("\n %2.f\n\n", RetornaU(l));
			break;
		}
	case 7:
		{
			imprime(l);
			printf("\n\n");
			break;
		}
	default:
		printf("\n opção Invalida !!!\n");
	}

}

	  return  0;
}