Alguem sabe me dizer o porquê do magica virar um numero absurdamente grande do nada, sendo que algumas linhas antes coloquei pra ele ser igual a dois.

Bruno Benedetti · 19 de fevereiro de 2016

Alguem sabe me dizer o porquê do magica[1] virar um numero absurdamente grande do nada, sendo que algumas linhas antes coloquei pra ele ser igual a dois. Percebi que se eu excluir a "numeroprimotest = numeroprimo;" ele para com o bug. Eu estou desconfiado que esse "int magica [0]" não pode ser usado porque invade a memória do float da linha debaixo, se for isso, alguém sabe como armazenar números infinitamente em um int? Se não existir pode ser em um char também!

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

int main (void){
    int numeroprimo,numerotest,i,a;
    int magica[0];
    float numeroprimotest;
    inicio:
    printf ("____________________N\351MEROS PRIMOS____________________ \n");
    printf ("Sequencia de numeros primos!\n");
    magica[1] = 2;
    a = 2;
    numeroprimo = 1;
    primo:
    numeroprimo = numeroprimo + 1;
    numeroprimotest = numeroprimo;
    i = 1;
    printf ("%i \n", magica[1]);
...
    system ("PAUSE");
    return 0;
}

Michael Douglas_787885 · 19 de fevereiro de 2016

Eu nem testei o seu código, mas pelo que eu vi aqui, você esta querendo acessar magica[1] sem ao menos ter criado um vetor que possa acessa-lo

na declaração de variavel, muda o int magica[0] para int magica[2]

ou então muda os magica[1] para magica[0]

além do mais você não precisava criar um vetor

Bruno Benedetti · 19 de fevereiro de 2016

É que assim, eu vou armazenar MUUUUUITOS números e não quero escrever int magica [999999] então optei pelo [0] pra resolver o problema. E testando ele funcionou, ele armazena infinitamente, se eu armazenar algo no mágica [191629] ele vai armazenar, e é isso que eu preciso, algo algo que armazene muitos números sem um limite definido.

Michael Douglas_787885 · 19 de fevereiro de 2016

Você disse que o problema era que o magica[1] tava dando um numero estranho

O motivo do numero estranho é que você criou um vetor de 0 posições e quer acessar a posição de indice 1, que no caso essa posição é inexistente, e ae da esse numero

defina o tamanho do vetor como por exemplo:

int tamanho = 1;
int magica[tamanho];

while(magica[tamanho] != 0)
{
     printf("Digite um numero: ");
     scanf("%d", &magica[tamanho]);
    tamanho++;
}

Bruno Benedetti · 19 de fevereiro de 2016

@Michael Douglas_787885 na real não. Se eu fizer isso logo depois de dar o comando pra ele ficar dois e dar um printf ele vai estar como dois. Como falei antes, eu testei, e ele se comporta como um [infinito]. O [0] é diferente de um [2] que não armazena nada no [3], entendeu?

FelipePetropolis · 19 de fevereiro de 2016

Olá!

Olha sou inciante em C . . .

Cara ate entendo o que você quer fazer, mas pelo que sei o jeito mais seguro, se não o ÚNICO é utilizando um vetor dinamicamente alocado, tente dar uma pesquisada sobre isso, se possível tento postar tópicos que já vi aqui mesmo no fórum que tratam sobre esse assunto . . .

Mas Tenho algumas duvidas, não quero passar a ideia de prepotencia ou arrogancia, mas . . .:

- onde você leu ou aprendeu que definindo uma variável como:

int magica [ 0 ];

a mesma iria armazenar uma quantidade infinita de números?

- sobre a sua citação:

E testando ele funcionou, ele armazena infinitamente, se eu armazenar algo no mágica [191629] ele vai armazenar

Existem uma serie de fatores que podem contribuir para o sucesso ou o fracasso dessa sua afirmação, mas você poderia ter a gentileza de nos dizer se você realmente testou essa sua hipotipose, principalmente atribuindo valores a CADA posição do vetor:

criando uma variável como:

int magica [ 0 ];

e colocando um valor em:

magica [ 191629 ];

ele vai armazenar ! ! !

Essa duvida me veio atona porque sabendo como a linguagem c funciona e fazendo um pequeno teste aqui para a sua hipótese, atribuindo um valor numérico a CADA posição, em determinado momento recebi uma mensagem de falha de segmentação de memoria, normalmente associado a tentativa de acessar partes da memoria não alocados para o meu algoritmo.

Apenas lembrando que dependendo de uma conjectura de fatores da sua maquina, envolvendo:

# o compilador e a forma como o mesmo está configurado;

# o tamanho da memoria que você possui na sua maquina;

# a quantidade de programas em execução;

# e a forma como o sistema operacional esta usando e redistribuindo os recursos de memoria da maquina;

As chances de você receber alguma mensagem de ERRO, são no mínimo enormes, pois aqui nem com 50 números, consigo executar o algoritmo sem receber a mensagem de falha de segmentação de memoria ! ! ! ! !

Bom por hora é isso . . . tente buscar informações sobre vetores dinamicamnete alocados que certamente funcionarão para o que você quer fazer, e nos diga se com os testes que lhe pedi você não recebeu nenhuma mensagem de erro do seu programa.

E como eu já disse tente buscar no fórum Tópicos sobre esse assunto, se possivel tento postar algo ainda hoje!

Obervações:

- Tente postar qualquer mensagem de erro ou alerta que o compilador ou a IDE lhe retornem, ou mesmo qualquer mensagem ao final de execução do seu programa.

- Aqui o algoritmo parace estar funcionando, pois, o numero 2 é printado na tela . . .

Ubuntu 14.04 GCC 4.8 CodeBlocks 13.12

Espero Ter Ajudado ! ! !

Bruno Benedetti · 19 de fevereiro de 2016

@FelipePetropolis

Eu tinha feito esse teste, e tinha funcionado perfeitamente, mas quando coloquei 1000 no lugar do 100 ele travou... Achei que como se repetiu 100 vezes sem travar ele não iria mais. Então realmente o [0] não funciona. Vou pesquisar o que você disse dos vetores dinamicamente alocados e tentar resolver com isso. Quando terminar retorno aqui o código inteiro!

O método de vetores dinamicamente alocados não funciona, ele enche a memória rapidamente. O método que vai funcionar é o de listas encadeadas, mas pelo que estou vendo é bem complicado, porém vou tentar!

#include <stdio.h>
#include <stdlib.h> //system
#include <stdio.h> // \numero para acentos 
#include <string.h>
int main (void){
    int i;
    int numero1;
    int letra1[0];
    i = 1;
    numero1 = 1;
    while (letra1[i] != 100){
        numero1 = 1 +numero1;
        i = 1 + i;
        letra1[i] = numero1;
        printf ("%i\n",letra1[i]);
    }
    printf ("%i\n", letra1[15]);
    
    system ("PAUSE");
    return 0;
}

CiroboyBR · 19 de fevereiro de 2016

@Bruno Benedetti Posso perguntar para que você quer armazenar um número teoricamente infinito?

Bruno Benedetti · 19 de fevereiro de 2016

@CiroboyBR Não é um numero infinito, são infinitos números em uma mesma int. Eu vou calcular os primos, como fiz nesse algorítimo:

#include <stdio.h>
#include <stdlib.h> //system
#include <stdio.h> // \numero para acentos 
#include <string.h>
/* Desenvolvido por Bruno Perin Benedetti */
int main (void){
	int numero1,numeroprimo,numerotest,verificador;
	float numeroprimotest;
	inicio:
	printf ("____________________N\351MEROS PRIMOS____________________ \n");
	printf ("Sequencia de numeros primos!\n");
	numeroprimo = 1;
	primo:
	numeroprimo = numeroprimo + 1;
	numero1 = 1;
	teste:
	numero1 = numero1 + 1;
	numeroprimotest = numeroprimo;
	if (numero1 < numeroprimotest){
		numeroprimotest = numeroprimotest / numero1;
		numerotest = numeroprimotest;
		numeroprimotest = numeroprimotest - numerotest;		
		if (numeroprimotest == 0){
			goto primo;
		}else{
			goto teste;
		}
	}else{
		printf ("O n\243mero %i \202 primo \n",numeroprimo);
		goto primo;
	}
	system ("PAUSE");
    return 0;
}

Só que quero melhorar ele. Nesse caso ele divide o numero que eu quero saber se é primo por todos os números maiores que 2, e portanto ele divide por números que n fazem sentido, não tem porque eu dividir por 4 se eu ja dividi por 2 e não deu primo, entendeu?? Então eu vou armazenando os primos no int e só dividindo pelos primos e com isso eu irei economizar muito processamento e conseguir calcular mais rápido. Pois os primos podem dividir todos os números que não sejam primos, entendeu?

@CiroboyBR Esse a pessoa digita o numero e ele diz se é primo ou não, e se não quando divisores tem e quais são eles. Mas aqui também, o algorítimo é mais lento porque ele divide por todos números possíveis e não pelos primos já descobertos.

#include <stdio.h>
#include <stdlib.h> //system
#include <stdio.h> // \numero para acentos 
#include <string.h>
/* Desenvolvido por Bruno Perin Benedetti */
int main (void){
	int numero1,numeroprimo,numerotest,verificador;
	float numeroprimotest;
	inicio:
	printf ("____________________N\351MEROS PRIMOS____________________ \n");
	printf ("Digite um n\243mero natural maior que um para verifica\207\306o:\n");
	scanf ("%i", &numeroprimo);
	numero1 = 2;
	numeroprimotest = numeroprimo;
	verificador = 0;
	teste:
	if (numero1 < numeroprimotest){
		if (numeroprimotest > 1){
			numeroprimotest = numeroprimotest / numero1;
			numerotest = numeroprimotest;
			numeroprimotest = numeroprimotest - numerotest;
		}else{}
		if (numeroprimotest == 0){
			printf ("O n\243mero %i \202 divis\241vel por %i. \n",numeroprimo, numero1);
			numero1 = numero1 + 1;
			numeroprimotest = numeroprimo;
			verificador = verificador + 1;
			goto teste;
		}else{
			numero1 = numero1 + 1;
			numeroprimotest = numeroprimo;
			goto teste;	
		}
	}else{
		if (numeroprimo == 1 || numeroprimo == 0){
			printf ("Digite um n\243mero v\240lido!\n");
			system("pause");
			system("cls");
			goto inicio;
		}else{
			if (verificador > 0){
				printf ("Verifica\207\306o conclu\241da, o n\243mero %i \202 divis\241vel por %i n\243mero(s). \n",numeroprimo, verificador);
			}else{
				printf ("O n\243mero %i \202 primo! \n", numeroprimo);
			}
		}
	}
	system ("PAUSE");
    return 0;
}

CiroboyBR · 20 de fevereiro de 2016

@Bruno Benedetti Você não está a pensar direito no seu algoritmo.

Primeira maneira: Você não precisa guardar todos os números primos digitados para só depois calcular se ele é primo, você pode com apenas 1 variável int/string, solicitar ao usuário que digite o número e após isso calcular se mesmo é ou não primo. Use um WHILE ou um FOR para fazer um loop.

Segunda maneira: Se você realmente precisar ou quiser armazenar esses números, você pode guarda-los em um arquivo.txt, depois é só sair lendo. para isso você usa as funções do C para manipulação de arquivos e de novo, você só vai precisar de uma variável int/string.

Se você realmente precisar ou quiser armazenar esses números e preza pelo desempenho do seu algoritmo, sugiro utilizar uma alocação estática, o num[9999999] pode parecer bizarro mais é muito eficiente no quesito desempenho.

Bruno Benedetti · 20 de fevereiro de 2016

@CiroboyBR eu não quero descobrir um número, se fosse isso eu usaria o último algoritmo que postei. Eu quero calcular todos os primos. Portanto a primeira maneira está descartada.

Referente a segunda maneira, eu não sei mexer com txt em C, pois sou iniciante, então vou pesquisar sobre isso e posto aqui se deu certo!

Ja o terceiro método que você falou estoura a memória rapidamente, portanto não é eficaz, pode testar, meu PC faz ele parar de funcionar em menos de 5 segundos.

CiroboyBR · 20 de fevereiro de 2016

@Bruno Benedetti Se você precisa armazenar uma gigantesca quantidade de números, então sua única saída é manipulação de arquivos, pois ao que parece você está limitado pela memória RAM, mesmo alocando dinamicamente, vai chegar um momento que vai faltar memória RAM no seu PC. Então sugiro aprender a manipular arquivos em C, não é difícil.

Nesse link tem algumas vídeo aulas, e as aulas 66~79 falam sobre arquivos.

https://programacaodescomplicada.wordpress.com/indice/linguagem-c/

Bruno Benedetti · 20 de fevereiro de 2016

Consegui! Usei o [99999999] e dessa vez não travou! Na realidade ele travou em um numero bem alto com 7 dígitos o que está bom pra mim.

Segue as prints da mudança na rapidez do algorítimo. Os dois foram abertos ao mesmo tempo, na esquerda o antigo (testando todos números) e na direita o novo (só os primos).

http://prnt.sc/a5tar8

http://prnt.sc/a5tav3

http://prnt.sc/a5tb0z

@CiroboyBR Vou estudar isso sim, até ja fiz uns testes e pelo visto vai ficar bem mais rápido e não vai travar quando chegar em um numero muito alto.

Valeu a ajuda de todos!