C++ Como criar um array de char infinito?

LinsmarVital · 30 de outubro de 2019

Bom, tenho um trabalho pra fazer em c/c++ que funciona da seguinte maneira:
Existe um arquivo de entrada .txt, com 2 listas de números, tenho que pegar essas 2 listas, juntar as 2 e me livrar das duplicatas e jogar o resultado em outro txt, exemplo:
entrada.txt:
[1 2 23 42] [3 32 4 23 1]
saida.txt:
[1 2 3 4 23 32 42]
Não precisa estar ordenado que nem no exemplo acima.
Eu fiz, lendo char por char, ignorei o primeiro '[', depois verifiquei se vinha algo diferente de ']' em seguida e se viesse, eu ia pondo o caracter num array que fiz assim:
char *caracVetor = (char *) malloc(sizeof(char)*2147483647);
Quando chegasse no espaço, parava e transformava o array em inteiro, com a função atoi.

//Passando o que tem dentro do arquivo para a 1ª lista
    fscanf (in, "%c", &caracter); //Lendo o caracter '['
    for (; caracter != ']';) { //O for funciona enquanto caracter for diferente de ]
        fscanf(in, "%c", &caracter);
        if (caracter == ']') break; //Se achar o caracter ] logo de cara, acaba o loop.
        else {  //Se não:
            for (int o = 0; caracter != ' '; o++) { //Loop pra pegar números grandes
                caracVetor[o] = caracter; //Joga o caracter dentro do vetor de caracteres
                fscanf (in, "%c", &caracter); //Ve quem é o proximo no arquivo
                if (caracter == ' ' || caracter == ']') { //Se for espaço ou ], acaba
                    aux = atoi(caracVetor); //Transforma o vetor de caracteres em inteiro
                    break;
                }
            }
            insert(aux, h1); //Insere na lista 1
            qntdLista1++;
            free(caracVetor);
        }
    }

Está dando tudo certo, o problema é o seguinte(paranoia minha):
E se o professor por como exemplo um número maior que 2147483647?
Entendo que posso mudar a struct da lista e fazer ela aceitar long int invés de só int e também posso aumentar esse número no malloc, mas tudo tem 1 limite. Existe alguma forma de quebrar esse limite? Se o professor por um número como "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" existe alguma forma de eu pegar ele no arquivo e transformar em inteiro depois? Ou é impossível e nem preciso me preocupar com isso?

Ansi C · 30 de outubro de 2019

@LinsmarVital Boa Noite!

4 horas atrás, LinsmarVital disse:

Se o professor por um número como "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"

Esse não é o maior número do mundo, mas é grande o bastante para não caber em um tipo primitivo. Acredito que ele (o professor) esteja sem razões para solicitar sua implementação. Fique tranquilo.

4 horas atrás, LinsmarVital disse:

existe alguma forma de eu pegar ele no arquivo e transformar em inteiro depois?

Como disse, esse não é o maior inteiro já calculado. Para determina-lo seria necessário algumas implementações especificas e talvez outro membro apareça mais tarde para essa discussão.

4 horas atrás, LinsmarVital disse:

E se o professor por como exemplo um número maior que 2147483647?

Qualquer x > 2147483647 cabe em tipos primitivos. Já quando se fala de qualquer x >>> 2147483647 (nas proximidades de 2^277.232.917 – 1) então não é tão simples como fazer um bolo.

arfneto · 31 de outubro de 2019

Citação

Como criar um array de char infinito?

Sim, basta ter um computador com memória infinita.Esqueça isso.Seu problema não é esse.

21 horas atrás, LinsmarVital disse:

Bom, tenho um trabalho pra fazer em c/c++

Entenda que vai ter que escolher entre C e C++. São linguagens totalmente diferentes.

21 horas atrás, LinsmarVital disse:

Existe um arquivo de entrada .txt, com 2 listas de números, tenho que pegar essas 2 listas, juntar as 2 e me livrar das duplicatas e jogar o resultado em outro txt, exemplo:
entrada.txt:
[1 2 23 42] [3 32 4 23 1]
saida.txt:
[1 2 3 4 23 32 42]
Não precisa estar ordenado que nem no exemplo acima.
Eu fiz, lendo char por char, ignorei o primeiro '[', depois verifiquei se vinha algo diferente de ']' em seguida e se viesse, eu ia pondo o caracter num array que fiz assim:
char *caracVetor = (char *) malloc(sizeof(char)*2147483647);

Veja que mostrou um exemplo onde os arquivos tem uns míseros 20 bytes cada um, mas tentou alocar 2 bilhões deles, mais 147 milhões e uns trocados. Não faz sentido. Esse não é por certo o objetivo de seu programa: testar limites da máquina.ou da memória ou os dois. Se for esse me desculpe...

Eis o que acho que deve fazer:

antes de tudo resolva se vai usar C ou C++ e poste aqui
seu enunciado garante que não há duplicatas nos arquivo iniciais? Você precisa saber isso porque se ele não garante e na saída não pode ter você vai ter que programar isso também. Entende?
vou imaginar que vai usar C pelo que li do seu código

sobre um algoritmo:

escolha um dos arquivos
leia até o fim e grave em uma estrutura de dados na memória de sua máquina
use uma estrutura que permita inserir já em ordem para facilitar buscar duplicatas, como uma lista encadeada ou algo como grupos de vetores
feche o arquivo inicial
já pode gravar tudo isso no arquivo de saída: o conteúdo do arquivo 1 sem duplicatas.
abra o outro e vá lendo
a cada número que encontrar verifique se não está já na estrutura que montou com os números do primeiro e se não for uma duplicata grave na saída e insira em sua estrutura

Sobre os limites:

Rode esse programa em sua máquina e ele vai dizer o tamanho do maior vetor que pode alocar num dado momento. Note que é só um brinquedo. Não serve para muito porque é uma coisa dinâmica e se alocar tudo isso ou perto seu micro vai praticamente parar porque o sistema precisa continuamente de memória pra rodar outras coisas E se seu programa for interrompido até salvar o contexto dele em disco vai levar uma eternidade. E se for um computador compartilhado vocè vai ser culpado por muitos problemas...

#include "stdio.h"
#include "stdlib.h"

int main(int argc, char* argv)
{
    const unsigned long      k = 1024;    
    const unsigned long      megabyte = 1024 * k;
    const unsigned long      gigabyte = 1024 * megabyte;
    unsigned long            maior_valor = k;    // inicia em 1k bytes
    unsigned long            i;
    unsigned long            maxGB = 0;
    unsigned long            maxMB = 0;

    char* area;

    printf("Alocando Gigabytes\n");
    for (maxGB = 1;; maxGB += 1)
    {
        area = (char*)malloc(maxGB*gigabyte);
        if (area == NULL)
        {
            printf("Erro para %ldGB\n", maxGB);
            maxGB -= 1;
            break;
        }
        else
        {
            free(area);
        }
    }
    printf("Sucesso com %d GigaBytes. Adicionando Megabytes\n", maxGB);

    for (i = 1023;; i -= 1)
    {
        int t = maxGB * gigabyte + i * megabyte;
        area = (char*)malloc(t);
        if (area == NULL)
        {
            continue;
        }
        else
        {
            free(area);
            maxMB = i;
            break;
        };    // end if
    };    // end for
    maior_valor = maxGB * gigabyte + maxMB * megabyte;
    printf("Sucesso com %d GigaBytes + %ld Megabytes = %ld bytes\n", maxGB, maxMB, maior_valor);
    printf("Tentando alocar de novo...\n");
    area = (char*)malloc(maior_valor);
    if (area != NULL)
    {
        printf("Sucesso!\n");
        free(area);
    }
    else
    {
        printf("ERRO!\n");
    };    // end if
    return 0;
}    // end main()

arfneto · 31 de outubro de 2019

Note que apesar de ser um raciocínio correto você não precisa converter nada. Segundo o enunciado são números e não devem estar duplicados na saída. Só isso.

Não vai operar com eles. Só vai comparar pra ver se tem outro igual e para isso não precisa converter. Apenas garanta que são dígitos e compare como string. Não perca seu tempo.