C Programar com números gigantes (Milhões)

by Owen · 23 de abril de 2020

Boa tarde galera, eu to tentando fazer um programa que faça a soma de todos os números, de 1 a 1.000.000, o resultado tem que ser 500.000.500.000, porém não consigo exibir essa quantidade de números utilizando o Long.

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

#define UMMILHAO 1000000
#define CEM 100

main()
{
      long double soma, contador;
      
      soma = 0;
      contador = 1;
      
//   
//     while (contador <= UMMILHAO)
//     {  // 1       0    1
//       //  3       1    2
//       // soma = soma + contador;
//          soma += contador;
//          contador++;
//     }
     
     for (contador = 1; contador <= UMMILHAO; contador++)
     {
         // 1       0    1
        //  3       1    2
       // soma = soma + contador;
          soma += contador;
     }

//
// while (contador <= CEM)
//     {  // 1       0    1
//       //  3       1    2
//       // soma = soma + contador;
//          soma += contador;
//          contador++;
//     }
     
   //  for (contador = 1; contador <= CEM; contador++)
//     {
//         // 1       0    1
//        //  3       1    2
//       // soma = soma + contador;
//          soma += contador;
//     }
          
     printf("\nSoma dos n%cmeros de 1 a 1000000: \n\n %d", 163, soma);
     printf("\n\n\n");

     system("PAUSE");
}

herbertbahia · 23 de abril de 2020

.

by Owen · 23 de abril de 2020

Aqui ta bugando.

herbertbahia · 23 de abril de 2020

interessante poderia me dizer onde voce viu que a soma deveria da 500.000.500.000? so por curiosidade , pois eu nunca ouvir falar.

Lucca Rodrigues · 23 de abril de 2020

@by Owen Da esse resultado mesmo... 500.000.500.000.

Teste isso:

#include <iostream>
#include <stdio.h>

int main()
{
    long long x, y;
    for (x=0,y=0; y<=1000000; y++){
        x+=y;
    }
    printf("%lld", x);
    return 0;
}

int é de -32767 até +32767 (16 bits)

long é de -2147483647 até +2147483647 (32 bits)

long long é de -9223372036854775807 até +9223372036854775807 (64 bits)

by Owen · 23 de abril de 2020

É um exercício que um professor me passou, não estou entendo o porque de não funcionar usando o long.

Lucca Rodrigues · 23 de abril de 2020

@by Owen Não vai conseguir exibir esse número com 32 bits apenas, tem que usar o long long...

arfneto · 23 de abril de 2020

4 minutos atrás, herbertbahia disse:

interessante poderia me dizer onde voce viu que a soma deveria da 500.000.500.000? so por curiosidade , pois eu nunca ouvir falar.

É uma progressão aritmética. Vem do ensino fundamental: a soma do primeiro mais o último, dividida por dois multiplicada pelo comprimento da série...
Como

    (1 + 4)/4 / 2 = 1 + 2 + 3 + 4 = 10

é a mesma coisa.

Direto de limits.h

Então com unsigned long long deve atingir esses números. Se precisa de algo arbitrariamente grande basta escrever uma soma em vetores de char, ou em meio char, a.k.a. BCD como em COBOL, e escrever as funções. No caso apenas a soma... Não é complicado afinal a gente faz no papel...

Mas precisa mesmo somar? A fórmula do ensino básico não serve?

adicionado 0 minutos depois

5 minutos atrás, by Owen disse:

É um exercício que um professor me passou, não estou entendo o porque de não funcionar usando o long.

Porque não cabe...

by Owen · 23 de abril de 2020

Utilizei o long long e funcionou, Obrigado galera

arfneto · 23 de abril de 2020

Para referência

sizeof(long long int) = 8 bytes
         0         1         2    2
         0    5    0    5    0    5
(8)  v =                  255
(16) v =                65535
(32) v =           4294967295
(32) v =           4294967295
(64) v = 18446744073709551615

O maior int sem sinal tem 20 dígitos e começa por 1. E os nomes das constantes estão abaixo.

#include "stdio.h"
#include "stdlib.h"
int main(int argc, char** argv)
{
	printf("sizeof(long long int) = %d bytes\n", sizeof(long long int));
	printf("         0         1         2    2\n", ULLONG_MAX);
	printf("         0    5    0    5    0    5\n", ULLONG_MAX);
	printf("(8)  v = %20u\n", UCHAR_MAX);
	printf("(16) v = %20u\n", USHRT_MAX);
	printf("(32) v = %20Iu\n", UINT_MAX);
	printf("(32) v = %20lu\n", ULONG_MAX);
	printf("(64) v = %20llu\n", ULLONG_MAX);
	return 0;
}

Matheus Maldi · 23 de abril de 2020

Inclua o header <stdint>h e utilize int64_t em vez de long ou long long, devido as incompatibilidade nos compiladores e arquitetura. Por exemplo nos compiladores que uso long tem 64 bits, já você deve estar utilizando compilação em 32 bits.

adicionado 7 minutos depois

10 minutos atrás, arfneto disse:

Para referência


sizeof(long long int) = 8 bytes
         0         1         2    2
         0    5    0    5    0    5
(8)  v =                  255
(16) v =                65535
(32) v =           4294967295
(32) v =           4294967295
(64) v = 18446744073709551615

O maior int sem sinal tem 20 dígitos e começa por 1. E os nomes das constantes estão abaixo.


#include "stdio.h"
#include "stdlib.h"
int main(int argc, char** argv)
{
	printf("sizeof(long long int) = %d bytes\n", sizeof(long long int));
	printf("         0         1         2    2\n", ULLONG_MAX);
	printf("         0    5    0    5    0    5\n", ULLONG_MAX);
	printf("(8)  v = %20u\n", UCHAR_MAX);
	printf("(16) v = %20u\n", USHRT_MAX);
	printf("(32) v = %20Iu\n", UINT_MAX);
	printf("(32) v = %20lu\n", ULONG_MAX);
	printf("(64) v = %20llu\n", ULLONG_MAX);
	return 0;
}

Não utilize isso, meu compilador retorna 18446744073709551615 para ULONG_MAX .

Utilize assim:

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

int main(int argc, char** argv)
{
	printf("sizeof(long long int) = %d bytes\n", sizeof(long long int));
	printf("         0         1         2    2\n", UINT64_MAX);
	printf("         0    5    0    5    0    5\n", UINT64_MAX);
	printf("(8)  v = %20u\n", UINT8_MAX);
	printf("(16) v = %20u\n", UINT16_MAX);
	printf("(32) v = %20lu\n", UINT32_MAX);
	printf("(64) v = %20llu\n", UINT64_MAX);
	return 0;
}

arfneto · 23 de abril de 2020

52 minutos atrás, Matheus Maldi disse:

nclua o header <stdint>h e utilize int64_t em vez de long ou long long, devido as incompatibilidade nos compiladores e arquitetura. Por exemplo nos compiladores que uso long tem 64 bits, já você deve estar utilizando compilação em 32 bits

esses são tópicos de estudantes. Evito ao máximo incluir novos headers ou comandos não ortodoxos. Como você deve ter percebido mesmo o long long int era novidade para o autor...

O mesmo programa, mas com o printf() em hexadecimal junto com o decimal

sizeof(long long int) = 8 bytes
         0         1         2    2
         0    5    0    5    0    5
(8)  v =                  255
Hex  v =                   FF
(16) v =                65535
Hex  v =                 FFFF
(32) v =           4294967295
Hex  v =             FFFFFFFF
(32) v =           4294967295
(32) v =             FFFFFFFF
(64) v = 18446744073709551615
Hex  v =     FFFFFFFFFFFFFFFF

O "programa"

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

int main(int argc, char** argv)
{
	printf("sizeof(long long int) = %d bytes\n", sizeof(long long int));
	printf("         0         1         2    2\n");
	printf("         0    5    0    5    0    5\n");
	printf("(8)  v = %20u\n", UCHAR_MAX);
	printf("Hex  v = %20X\n", UCHAR_MAX);
	printf("(16) v = %20u\n", USHRT_MAX);
	printf("Hex  v = %20X\n", USHRT_MAX);
	printf("(32) v = %20Iu\n", UINT_MAX);
	printf("Hex  v = %20X\n",  UINT_MAX);
	printf("(32) v = %20lu\n", ULONG_MAX);
	printf("(32) v = %20X\n",  ULONG_MAX);
	printf("(64) v = %20llu\n", ULLONG_MAX);
	printf("Hex  v = %20llX\n",   ULLONG_MAX);
	return 0;
}

Quando uso alguma API que usa esses tipos eu incluo o header. Mas é opção de cada um. E nunca compilo em 64 bits a menos que seja o objetivo do projeto. Você tem razão quanto a isso.

isrnick · 1 de maio de 2020

Modificado:

#include <stdio.h>
#include <limits.h>

int main(int argc, char** argv)
{
	printf("sizeof(long long int) = %lu bytes\n", sizeof(long long int));
	printf("         0         1         2    2\n");
	printf("         0    5    0    5    0    5\n");
	printf("(8)  v = %20u\n", UCHAR_MAX);
	printf("Hex  v = %20X\n", UCHAR_MAX);
	printf("(16) v = %20u\n", USHRT_MAX);
	printf("Hex  v = %20X\n", USHRT_MAX);
	printf("(32) v = %20u\n", UINT_MAX);
	printf("Hex  v = %20X\n",  UINT_MAX);
	printf("(32) v = %20lu\n", ULONG_MAX);
	printf("(32) v = %20lX\n",  ULONG_MAX);
	printf("(64) v = %20llu\n", ULLONG_MAX);
	printf("Hex  v = %20llX\n",   ULLONG_MAX);
	return 0;
}

Versão com todos os limites de inteiros copiada do site https://en.cppreference.com/w/c/types/limits :

#include <stdio.h>
#include <limits.h>
 
int main(void)
{   
    printf("CHAR_BIT   = %d\n", CHAR_BIT);
    printf("MB_LEN_MAX = %d\n", MB_LEN_MAX);
    printf("\n");
 
    printf("CHAR_MIN   = %+d\n", CHAR_MIN);
    printf("CHAR_MAX   = %+d\n", CHAR_MAX);
    printf("SCHAR_MIN  = %+d\n", SCHAR_MIN);
    printf("SCHAR_MAX  = %+d\n", SCHAR_MAX);
    printf("UCHAR_MAX  = %u\n",  UCHAR_MAX);
    printf("\n");
 
    printf("SHRT_MIN   = %+d\n", SHRT_MIN);
    printf("SHRT_MAX   = %+d\n", SHRT_MAX);
    printf("USHRT_MAX  = %u\n",  USHRT_MAX);
    printf("\n");
 
    printf("INT_MIN    = %+d\n", INT_MIN);
    printf("INT_MAX    = %+d\n", INT_MAX);
    printf("UINT_MAX   = %u\n",  UINT_MAX);
    printf("\n");
 
    printf("LONG_MIN   = %+ld\n", LONG_MIN);
    printf("LONG_MAX   = %+ld\n", LONG_MAX);
    printf("ULONG_MAX  = %lu\n",  ULONG_MAX);
    printf("\n");
 
    printf("LLONG_MIN  = %+lld\n", LLONG_MIN);
    printf("LLONG_MAX  = %+lld\n", LLONG_MAX);
    printf("ULLONG_MAX = %llu\n",  ULLONG_MAX);
    printf("\n");
}

isrnick · 1 de maio de 2020

@vangodp No meu não deu nenhum warning, e eu até adicionei as flags de compilação para os warnings de formatação manualmente para ter certeza. Provavelmente é a versão do compilador que você está usando, ou alguma flag de compilação que está usando.

Verifique que está com flag de versão da linguagem para C99 ou mais recente (ex: -std=c99 , ou -std=gnu11 , ou -std=c11 , etc), o meu está com -std=gnu11 .

Se isso não resolver, então coloque a tag de compilação:

-D__USE_MINGW_ANSI_STDIO=1

Ou então inclua no código (antes do stdio.h):

#define __USE_MINGW_ANSI_STDIO 1

Para forçar a usar stdio.h padrão ao invés da versão da Microsoft.

arfneto · 1 de maio de 2020

5 horas atrás, vangodp disse:

????

Nenhum comentário?

Não rodou em sua máquina? Se está preocupado com os warnings mude o tipo do parâmetro em seu arquivo. Eu me prometi usar sempre o mesmo ambiente quando uso o forum, e não usar outros compiladores. Apesar de não me importar muito com Warnings meu compilador parece satisfeito com esseE aqui roda sem problemas. Uso sempre Windows 10 e Visual Studio

Claro que em tempos de confinamento e para checar uma dúvida de um usuário aqui acabei instalando um certo Dev-C++ e um Code::Blocks e gcc 5.1 e 8.2. Mas daí a eu usar será outro passo... Tenho máquinas Linux aqui. Meu servidor VOIP fica na mesma mesa até e roda Centos. Tem SUSE e UBUNTU no WSL, tem o bd com UBUNTU 18 ou 17 sei lá, mas não quero mexer nessas máquinas.

Então uso só essa velhinha aqui com VS Code e Visual Studio mesmo. Quando escrevo algo e posto nesse forum sempre é a partir dessa máquina. Se deixo o programa online apenas posto o link do git porque meu ambiente já deia o programa lá então não preciso fazer nada.

Mas talvez fosse legal usar só Linux e gcc e postar os programas e o makefile como nos velhos tempos. Exceto que nos velhos tempos não tinha esse lance de postar

isrnick · 2 de maio de 2020

arfneto · 2 de maio de 2020

9 horas atrás, vangodp disse:

Estou usando o ultimo codeblocks(oficial). Suponho que seja das ultimas versões de mingw.

Se você instalou depois de 2017 e antes de 19 de março de 2020 o compilador incluído era o 5.1. Esse ambiente não é atualizado com frequência como vê...

9 horas atrás, vangodp disse:

Não sei o que dizer

Podia ter perguntado em qual versão foi compilado o exemplo pelo autor do post. Seria o simples. Era o CL 19.25 o compilador

9 horas atrás, vangodp disse:

Continuo sem saber o que lhe digo. Somente que uso codeblocks conjunto mingw(quase sempre a ultima versão)

Se não mudou a versão do compilador ou não instalou outro, já sabe qual teria: 5.1 até 19 de março ou 8.2. Eu instalei esses outro dia nesse Code::Blocks por causa de uma questão de um usuário nesse mesmo forum e por isso ainda estão nessa máquina que uso. E por isso me lembro

9 horas atrás, vangodp disse:

gostos... questão de gostos

Não. Não é. Apenas o ambiente de trabalho no Windows. E por isso evito mudanças. Ou usar máquinas que tenham coisas de clientes.

10 horas atrás, vangodp disse:

Nem lhe aconselho... sei que em linux vai tudo como a seda

Não tenho problemas com elas mesmo. Mas não tenho problemas no Windows também.

isrnick · 2 de maio de 2020

Eu pego a distribuição Nuwen:

https://nuwen.net/mingw.html

A versão atual da distro ( 17.1 ) já inclui GCC 9.2.0 e mingw-w64 7.0.0, e também inclui várias bibliotecas úteis em um único pacote, então não preciso baixar cada um separadamente, e já terei elas quando eu precisar.

arfneto · 2 de maio de 2020

1 hora atrás, isrnick disse:

Eu pego a distribuição Nuwen:

https://nuwen.net/mingw.html

A versão atual da distro ( 17.1 ) já inclui GCC 9.2.0 e mingw-w64 7.0.0, e também inclui várias bibliotecas úteis em um único pacote, então não preciso baixar cada um separadamente, e já terei elas quando eu precisar.

@isrnickImagino que não tenha lido o que escrevi acima. A versão 20.03 saiu em 19 de março de 2020.

Por falar na distribuição nuwen, direto da documentação:

Para quem está aprendendo C++ e usa Windows o autor da distribuição recomenda o simples: usar 2 compiladores. A última versão de gcc e a de MS Visual C++.

O jeito mais simples de ter o compilador da Microsoft é baixar Microsoft C++ Build Tools.

Claro que o Visual Studio pode incluir o compilador C/C++, basta marcar no formulário

Mas para quem precisa apenas do compilador essa é a opção recomendada. Pela Microsoft.

O lar do gcc é https://gcc.gnu.org/install/binaries.html

3 horas atrás, vangodp disse:

você não pode estar mais errado XD-> Code::Blocks Nightly Builds

@vangodp Acho que sabe a diferença entre Releases e Nightly Builds. Isso aqui abaixo está lá no site do Code::Blocks hoje e o passado não vai mudar:

Ninguém faz nada sério com Nightly Builds... Bem, até onde eu sei.

E se tivesse nesses 3 anos algo de qualidade para liberar você deve imaginar que os autores o teriam feito entre 2017 e 2020. Por exemplo atualizar para uma versão compilada usando uma versão mais atual de wxWidgets que era o freio mais óbvio na performance do Code::Blocks

E incluir versões mais novas de gcc teria sido uma cortesia pelo menos. Isso acho uma preguiça sem tamanho, porque mudar o download a cada versão maior de gcc não seria assim difícil. E deixar para o usuário é um sinal de descaso: até a versão 20 sempre incluia o gcc 5

3 horas atrás, vangodp disse:

você não pode estar mais errado XD-> Code::Blocks Nightly Builds

Se isso conta, então estou errado. Me desculpe.

2 horas atrás, vangodp disse:

Isso porque você ainda n compilou seu programa com mingw né

Na verdade eu não me lembro de problemas mesmo. Ao menos de problemas causados pelo compilador e não por mim ou pelos projetos em si. Mas nesses casos são coisas para Linux desenvolvidas em Linux.

Mas a partir de um problema de usuário desse forum tive um problema do com o gcc em Windows e deixei pra lá. Tudo em torno de usar

        clock_gettime();

e timespec. Claro que o equivalente

	timespec_get();

funciona perfeitamente em Windows e deixei pra lá.

Não gosto de perder mas era algo secundário e eu desisti de tentar usar essa função ou alguma irmã no gcc em Windows.

E também um programa de décadas atrás que chama muitas funções de console como FillConsoleOutputAttribute() e eu deixei pra lá. O problema do usuário não era esse e eu confesso que DESISTI dos dois casos.

3 horas atrás, vangodp disse:

Sei que o visual studio é mais aceitado no mundo empresarial, mas como só uso compiladores e esses tipos de programa a modo de estudo fico com codeblocks pois estou mais acostumado com ele. Um dia talvez migre porém n sei se vou para o visual studio

É o mesmo caso no mundo acadêmico. Visual Studio é a ferramenta comum. Em pesquisa e na indústria muitos usam as ferramentas da Intel e os kits SDK das GPU claro. E o Qt Creator no caso dos clientes do framework, que não são poucos, como no mundo automotivo e de instrumentação.

E tem as empresas clientes da Embarcadero, que tem acesso ao C++ Builder, bem refinado por sinal. O VCL é um conceito e tanto.

No mundo dos games acho que não muda muito também já que os engines gravitam todos em torno de DirectX e builds especializados dentro do Visual Studio.

Claro, tem ferramentas alternativas excelentes, mas não acho que Code::Blocks entraria em nenhum lugar. Nunca vi ao menos. Mesmo nos cursos iniciais no Brasil eu acho estranho. Não sei explicar.

Eclipse e Netbeans são muito bons e você pode encontrar empresas usando. E se pode usar de graça

Visual Studio Code é algo interessante e vem ganhando usuários muito rápido nos cursos e escolas. As ferramentas de debug multiplataforma são impressionantes. Há muito material online sobre isso. Você pode escrever para Linux ou Mac no Windows, usar o debugger do Linux ou do Windows, e fazer umas coisas impressionantes mesmo com Windows e WSL por exemplo. E como é grátis e o mercado de extensões é aberto já tem centenas delas. Lembra o ecossistema npm/node. Claro, muito longe ainda.

JetBrains cria IDEs fantásticos e agora você pode usar CLion. E para escolas é grátis, então seria uma opção a considerar. Eu uso O IDEA, IDE para java, e é muito produtivo. E todo mundo usa. Imagino que CLion seja do mesmo nível. Nunca usei na verdade, mas imagino que empresas que usam IDEA e java vão passar a usar CLion ou ao menos testar para desenvolver em C++. A licença adicional é barata e tem um preço para poder todos os IDE JetBrains com uma licença só.

Eu sei que nunca entrei em um banco, uma indústria ou universidade que não usasse largamente Visual Studio em Windows. Não vou dizer há quanto tempo entro nesses lugares para estudar, ensinar ou prestar serviço para não ficar deprimido. Ainda mais hoje em dia com essa história de pandemia e grupos de risco
E nunca entrei em uma empresa, mesmo um escritório pequeno de contabilidade ou algo assim, que usasse code:Blocks para algo.

isrnick · 2 de maio de 2020

14 minutos atrás, arfneto disse:

@isrnickImagino que não tenha lido o que escrevi acima. A versão 20.03 saiu em 19 de março de 2020.

O número de versão 17.1 que mencionei é a versão mais recente da distro nuwen, não fiz referência alguma ao codeblocks...

arfneto · 3 de maio de 2020

1 hora atrás, vangodp disse:

Pera ai... você tem algo em contra do codeblocks n é? >_<

Não. Não. Nem me importo com essas coisas. Mas eu instalei e usei minimamente e achei bem modesto. O IDE. O compilador gcc pode ser um inferno ou um bônus dependendo do contexto. Mais para inferno mesmo. CL é o óbvio se escreve para Windows e precisa simplesmente entregar o trabalho e receber.

Eu não conhecia sequer o ambiente do Code::Blocks até o ano passado. Fui a conhecer de ler pessoas falando disso aqui neste forum. Tentei usar e não me causou assim uma boa impressão. Parece antiquado e lento. E estou acostumado a facilidades e dificuldades de outros ambientes que sou obrigado a usar. E o ambiente do Visual Studio da Microsoft para desenvolver para Windows da Microsoft integrado ao GitHub, que agora é da Microsoft é algo digamos sólido. É muito produtivo. O debugger é muito bom. O ambiente tem de tudo. Refactoring pode não ser como os do IntelliJ mas é ok. IntelliSense é o máximo. Live Share para rever um projeto com até 30 caras em tempo real vendo o mesmo código pode não ser o CISCO WEbEx mas é bem interessante. E se você usa isso é maior a chance de se comunicar com alguém para escrever algo porque do outro lado também deve ter isso, seja num banco, numa indústria ou na NASA.

Usei Dev-C++ e me pareceu muito mais rápido e interessante. Mas se você usa Eclipse ou Netbeans porque é o IDE do cliente, ou Visual Studio, Ou IDEA ou o super moderno VS Code fica difícil se emocionar pleo Code::Blocks.

Mesmo editores como Sublime Text e Atom, alguma disciplina e um grupo de Makefiles são uma opção, eu acho. Mas Visual Studio com um emulador do vi do Linux como o https://marketplace.visualstudio.com/items?itemName=JaredParMSFT.VsVim é o ambiente que eu usaria no Windows se pudesse escolher.

Para hobby ou para estudantes provavelmente Visual Studio Code tem a interface mais legal. E tem outras vantagens se usar WSL. E o CLion se tiver acesso na escola pode ser uma grande aposta. A empresa que escreve isso escreve para desenvolvedores. E são muito muito bons. Parece que eles adivinham as coisas de que você precisa num projeto, os caras da JetBrains. Só é um pouco caro. Quase 9 dólares por mes para uso individual quando você pode ter Visual Studio Community por nada. VS Enterprise custa em torno de $45