Ansi C

Olá, de novo. Observe atentamente as saídas (linha por linha). Notará que as sequências são necessárias nas duas últimas saídas. Saídas (resultados) Para não recalcular os termos nas saídas soma e subtração são necessárias variáveis para memorizar as sequências em PA e PG, nesse caso se usa vetor. Caso não queira vetores, repita as expressões que calculam as sequências para produzir esses últimos dois resultados. Os Termos da PG estão arranjados e separados com vírgula (não por nova linha [\n]) #include"stdio.h" int main(void){ int n = 5 , a1 = 1 , q = 2 , an = a1; printf("PG: %d",a1); for(int i = 1; i<n; ++i){ an *= q; printf(",%d",an); } putchar('\n'); return 0; }

Olá, tudo bem? Espero que esteja bem. Para auxiliar a discussão na melhor forma, descreva seu objetivo, exponha quais eram|são as etapas|rotinas|operações do programa e os valores ideais|perfeitos de entrada e saída. No caso de ser um exercício escolar, compartilhe o 'print screen' do enunciado (completo), descreva quais pensa ser as etapas de uma solução e os assuntos que estudou, @chokex Caso tenha dúvida, compartilhe sua versão do código-fonte com dúvida.

Quer a impressão do contador, não somente a cada acúmulo de 1kk e sim também a cada incremento dele? Ao utilizar a impressão usual encheio a tela do terminal de caracteres, para contornar esse formato use o retorno ao inicial da linha com impressão carriage return ('\r'). #include"stdio.h" int main(void){ int contador = 0; while(contador<3000000){ ++contador; printf("\r%d",contador); if((contador%1000000)==0){ printf("\t%d\n",contador); } } return 0; } Assim ou estou viajando, @Thmpv

Olá, não esqueça de contemplar o máximo de comandos numa solução. São tantos comandos que obriga à dispensa das funções padrão para escrever essas rotinas na base de getchar() e putchar(). O que é, etc.? Talvez do, operador condicional (ternário), switch e goto, que corroboraria com a hipótese acima, @gabiz

@Gabrielbxs Existem milhares de coisas mais estimulantes que linguagem de programação, ninguém é punido por não lembrar|procrastinar um exercício no final de período principalmente de c! Solução é pedir adiamento, se ainda não pediu... peça até antes do início do período ou inserção de notas finais. Assista um desses vídeos de 5 horas de duração que existe no YouTube que lá pela metade terá compreendido o necessário para entregar esse trabalho e voltar a viver.

@Thmpv Ola, Aplicada as correções para esse exercício, espero que tenha iniciado a variável de controle do loop , reconheço em novos programadores algumas práticas que vejo em livros velhos encardidos de linguagem c que na atualidade são desnecessárias. Sugiro que declare, doravante, as variáveis junto a seu bloco lógico. Fora as questões estéticas, uma resposta tem seu código-fonte como este: #include"stdio.h" int main(void){ int contador = 1; while(contador<=3000000){ if((contador%1000000)==0){ printf("%d ", contador); } ++contador; } putchar('\n'); return 0; } OU #include <stdio.h> int main(void){ int contador = 1; while(contador<=3000000){ if((contador%1000000)==0){ printf("%d ", contador); } ++contador; } putchar('\n'); return 0; } Tentar é divertido, além humanamento impossível ter o registro exato, existe também a possibilidade de sua impressão ("1000000 2000000 3000000 ") não ocorrer número por número e sim de uma só vez; na saída do loop ou do programa. — É isso!

@Lipeco Aaaah! Meus Parabéns

Precisa de ajuda? Tem o esquema montadinho... agora é resolver cada ‘item’ igualmente o exemplo da atribuição da variável val; notou que existe uma curva da val a variável pr_b[1]? Essa é a deixa para o modus operandi do exercício. Exemplo: j) *(&ptr_b[1] - 2) + 3 Gabarito Tem dúvida pergunte @Lipeco

Penso que é um exercício de imaginação imaginativo, mas dessa maneira é necessário o(s) valor(es) inicial(is)|ou esquema(s) das alíneas. Tem isso ou estou viajando, @Lipeco

Foram boas postagens com temas que não entendia porque não respondia essa pergunta: No final, o Sr. respondeu! Se digo "No final" quero dizer penso que hoje de madrugada. Sinto muito, como assim? Sente muito, por quê? Por demostrar algo inútil e perigoso?

Então diga qual a versão que gostaria de ter visto, certamente não aquele que usou no programa abaixo (de tua autoria): int main(void) { int* de = (int[5]){1, 2, 3, 4, 5}; int* ate = de + 3; exibir_numeros(de, ate); exibir_numeros(ate, de); // tenta ao contrario return 0; } int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim); return -1; } int* p = ini; printf("Valores: ["); for (int* p = ini; p <= fim; p += 1) printf(" %d", *p); printf(" ]\n"); return 0; } A saída tem "0x0x..." porque a string de formato tem um padrão fora do especificador! Qual o compilador que gera programas sem esse padrão para justificar eles na printf? Então (eu penso que) não pode ou nem sequer deveria tentar, já que é inútil e perigoso. Olhe! Eu sinceramente desisto, não é possível entender seus comentários. — Eu agradeço! Agora sei, entendi... tudo faz muito sentido. Tks! Obrigado!

Está dizendo que as versões instaladas (compiladores) não são escritas conforme uma norma! Esse comentário ficou estranho. — para mim já temos o bastante de discussão sobre main, parâmetros, argumentos e variáveis não utilizadas. FUI!

Poise, eu também!

Tá! Mas, essa é uma resposta a uma pergunta que ser que fiz. Bom! O mesmo que entendi, não a razão para escrever main com parâmetros em sistemas simples ou quando não pretende utilizar. — Legal!

Não faz sentiddo uma norma iso C, não ter nada a ver com C. Então, que tivesse dito com o que tem a ver, senão com C. Com Java, tudo tem a ver com JAVA mesmo OK! Mas, como isso explica o porquê declarar ou não parâmetros na função main, caso tenha sido uma tentativa de explicar refaço a pergunta. Qual o sentido para declarar parâmetro|variável e não utilizá-la? Ata! Também não, por isso perguntei talvez tivesse algo a mais especialista, porém não há razão fundamental. Ainda sim, não existem parâmetros (na função), não difere tanto assim de int main (void). Ok! Mas, que justificativa é essa (principalmente porque não entendi). Então, experimentemos isso fora do prompt, e daí será que essa tal filosofia|religião tem mais adeptos (online). Por exemplo, com solicitação na impressão de arquivo. Outro no prompt — Filosofia...

A norma é complicada ou será que precisa de hábitos de leitura para acostumar com seu conteúdo, é muito formal|normal Caso tenha "leiteiros" iguais a mim que também não clicam em links de postagem, mas curte imagens|recortes de uma Normal (rascunho de Normal 2021), segue abaixo. Cansei de encontrar exemplos com argumento vazio ou indeterminado, nenhum desses exemplos tinha por objetivo escrever chamada recursiva da int main! A impressão que tiro dos exemplos é educar para não declarar desnecessariamente parâmetros|variáveis. Esse recorte é do especificar de impressão "%p" [Tradução]: Logo, se ativa o alerta (avisos) o compilador deve ter uma recomendação semelhante. Mas, curioso mesmo é a Norma deixar a impressão por conta da implementação, porque algumas podem corretamente escrever 0x... e outras não, daí fica o questionamento... não por quê? - ???

Penso que talvez esclareça melhor se falar o que significa não usar um variável|parâmetro|argumento?

Discordo que esteja pouco fora do tópico. É o contrário... a discussão é pertinente não somente às dúvidas com ponteiros: fragilidade, riscos e problematização de programar com linguagem de baixo nível igual à linguagem C (objeto primeiro da discussão), como também expressa importantes informações acerca de compiladores, protótipos de função, desperdício de memória, experimento de sintaxe, etc. A verdade, é que tudo está relacionado. Ou seja, a main não difere muito de outras funções: se tem argumento são alocados, senão... obvio não se reserva nada, tal qual todas as outras funções... logo quem programou o compilador tem razão, como é de se esperar. A escolha de palavras é típica de pessoa com muito idade (pensando bem isso não é preconceito é conceito), mas se ficou ofendido, eu retiro o que disse e permaneço dizendo que, refira-se ao meu nick name do mesmo modo que faz com os outros. De fato, não há nada de especial, muito comum.

Senhor..., que isso..., haja cordialidade..., além disso, evidente que és mais velho, logo dirija-se a meu nick name da mesma maneira que faz com demais. Com relação aos seus exemplos, agradeço muitíssimo, são tão caprichosos, nota-se o esforço para escrever sempre o melhor. O que digo: parabéns! Essa é uma informação pertinente, obrigado por compartilhar que eu não devo usar MSVC, se bem que nunca usei mesmo, então é soma de zeros. Na próxima vez vou simplesmente ignorar. Seria interessante, talvez antes de postar seus resultados, informasse também no topo qual o modelo do compilador, considere isso! É claro que eu notei sua intenção, e fiz igual mesmo... mostrei um exemplo análogo ao seu, no mínimo reforçando sua intenção, agora não resta dúvida quanto a fragilidade|usabilidade dos ponteiros. Ponteiros são velozes, mas sua usabilidade tem risco. Alguém ainda tem dúvida disso? Sabemos que isso está relacionado ao grau de liberdade dos ponteiros não existe maneira mais frágeis ou menos frágeis. Só frágeis: usei um exemplo que utiliza pilha, a falha não é imediata talvez não acontecesse desde que ficasse na pilha, um espaço alocado. Penso que, foi isso. Nota agora que apenas não considero interessante utilizar memória heap (alocação dinâmica de variáveis) para um experimento de risco, apesar de baixo. Só isso! MINHA OPINIÃO? Seja honesto... porque a opinião não é somente minha, mas também daqueles que implementam compiladores, o aviso não é exclusivo para alertar o desperdício de variável com assinaturas e argumentos da main, como está pretendendo educar com seu discursa dirigido à terceira pessoa, mas sim para desperdícios no programa. Ainda que não fossem ativados, pense... qual o sentido de escrever o protótipo da main com argumentos que não pretende utilizar? Apenas para reforça um correto, assim a maioria dos códigos iniciantes, a proposito quase sempre desse fórum, escreveríamos exemplos com dois argumentos e não com nenhum, sendo nenhum a maioria. Em resumo são 4 protótipos: 1. int main(int, int **); 2. int main(int, int *[]); 3. int main(void); 4. int main(); Quando não se dar utilidade para argumentos, recomenda (aviso) utilizar as assinaturas 3, 4 Aviso pega até os desperdícios menores: Desperdício e desperdício não importa o tamanho. Só observo seu conhecimento acerca da elite! Não entendi!

Ps.: Apenas por curiosidade: o for difere tanto assim de WHILE. Escolher entre um e outro é o quê? int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim); return -1; } int* p = ini; printf("Valores: ["); for (int* p = ini; p <= fim; p += 1) printf(" %d", *p); printf(" ]\n"); return 0; } --------------------------------------------------------------------------------- .LC0: .string "\nMostra valores de 0x%p a 0x%p (inclusive)\n" .LC1: .string "\nx: 0x%p e maior que u_: 0x%p\n" .LC2: .string "Valores: [" .LC3: .string " %d" .LC4: .string " ]" exibir_numeros: push rbp mov rbp, rsp sub rsp, 32 mov QWORD PTR [rbp-24], rdi mov QWORD PTR [rbp-32], rsi cmp QWORD PTR [rbp-24], 0 jne .L2 mov eax, -1 jmp .L3 .L2: cmp QWORD PTR [rbp-32], 0 jne .L4 mov eax, -1 jmp .L3 .L4: mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC0 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] cmp rax, QWORD PTR [rbp-32] jbe .L5 mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC1 mov eax, 0 call printf mov eax, -1 jmp .L3 .L5: mov rax, QWORD PTR [rbp-24] mov QWORD PTR [rbp-16], rax mov edi, OFFSET FLAT:.LC2 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] mov QWORD PTR [rbp-8], rax jmp .L6 .L7: mov rax, QWORD PTR [rbp-8] mov eax, DWORD PTR [rax] mov esi, eax mov edi, OFFSET FLAT:.LC3 mov eax, 0 call printf add QWORD PTR [rbp-8], 4 .L6: mov rax, QWORD PTR [rbp-8] cmp rax, QWORD PTR [rbp-32] jbe .L7 mov edi, OFFSET FLAT:.LC4 call puts mov eax, 0 .L3: leave ret --------------------------------------------------------------------------------- --------------------------------------------------------------------------------- int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim); return -1; } printf("Valores: ["); { int* p = ini; while (p <= fim){ printf(" %d", *p); ++p; } } printf(" ]\n"); return 0; } ----------------------------------------------------------------------------------- .LC0: .string "\nMostra valores de 0x%p a 0x%p (inclusive)\n" .LC1: .string "\nx: 0x%p e maior que u_: 0x%p\n" .LC2: .string "Valores: [" .LC3: .string " %d" .LC4: .string " ]" exibir_numeros: push rbp mov rbp, rsp sub rsp, 32 mov QWORD PTR [rbp-24], rdi mov QWORD PTR [rbp-32], rsi cmp QWORD PTR [rbp-24], 0 jne .L2 mov eax, -1 jmp .L3 .L2: cmp QWORD PTR [rbp-32], 0 jne .L4 mov eax, -1 jmp .L3 .L4: mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC0 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] cmp rax, QWORD PTR [rbp-32] jbe .L5 mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC1 mov eax, 0 call printf mov eax, -1 jmp .L3 .L5: mov edi, OFFSET FLAT:.LC2 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] mov QWORD PTR [rbp-8], rax jmp .L6 .L7: mov rax, QWORD PTR [rbp-8] mov eax, DWORD PTR [rax] mov esi, eax mov edi, OFFSET FLAT:.LC3 mov eax, 0 call printf add QWORD PTR [rbp-8], 4 .L6: mov rax, QWORD PTR [rbp-8] cmp rax, QWORD PTR [rbp-32] jbe .L7 mov edi, OFFSET FLAT:.LC4 call puts mov eax, 0 .L3: leave ret

— Dica final: ative os alerta do compilador, lembre-se, ele foi/é desenvolvido com ajuda da Elite da Programação.

O acesso é desreferenciar seguindo de leitura|gravação, isto é, se não desreferenciar um ponteiro com endereço ainda não alocado, não acontece a falha de segmentação, evidente que nada impede o programador de passar um endereço desalocado e com isso causar falha por engano|intencional|experimental. Uma estratégia é definir limite logicamente inválido: Como é o caso das ‘strings’ com ‘byte’ 0, outro exemplo é uma lista de idades com idade negativo, até mesmo fornecer o capacidade|tamanho|quantidade das variáveis vizinhas (vetor). Nesse último caso, o primeiro elemento do vetor (primeira variável) tem o seu tamanho e a implementação (função que operará esse vetor) tem potencial para captar esse tamanho, ainda assim, nada impediria um argumento qualquer nessas funções de causar falha lógica ou intencional. Não é O protótipo da main, mas sim UM protótipo da main, essa diferença é importante, apesar de parecer uma pouco pedante... A elite de programadores em C chegou no consenso de que há situações em que esses argumentos são dispensáveis, por conta disso tanto a norma quando os compiladores modernos são inflexíveis quando à declaração int main(...). Sendo main(int argc, char *arg[]) Sendo main(void) Sendo main() Sendo main(int argc, char **arg) Sendo que dois explicitamente descarta argumentos para aquelas situações em que são descartáveis. Observe que na sua exemplificação de como causar uma falha modificou o índice de um ponteiro. Nesse caso: Veja seu análogo: int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim[100]); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim[100]); return -1; } int* p = ini; printf("Valores: ["); for (int* p = ini; p <= fim; p += 1) printf(" %d", p[100]); printf(" ]\n"); return 0; } Nada difere em nada . Com relação os argumentos da função pensei o mesmo que a Elite da Programação, porém com há discussão de duplos ponteiros continuei seguindo contagiado. Concordo não haver garantia.

É impossível, pois o ponteiro (sendo uma variável) tem um número tal qual uma variável do tipo inteiro. Para impedir que acesse, é necessário pelo menos mais um ponteiro e com o número desse limite. Desse modo, um ponteiro é o início (a_) e o outro o fim (u_), note haver necessidade de modifique a expressão para duplo ponteiro. Exemplo. #include<stdio.h> #include<stdlib.h> void exibir_numeros (int **nums); int main(void){ int *a_ = (int [5]) {1,2,3,4,5}; int *u_ = a_ + 4; int **nums = (int * [2]) {a_, u_}; exibir_numeros(nums); return 0; } void exibir_numeros(int **nums){ int *x = nums[0]; while (x <= nums[1]){ printf(" %d ", x++[0]); } if (x > nums[1]){ printf("\nx: %p e maior que u_: %p\n", (void*)x, (void*)nums[1]); } return; } Sabe que nums[0] tem o mesmo endereço que em a_ e nums[1] o mesmo que u_. A expressão de controle do “loop” (while) testa se o endereço na x é menor_ou_igual _a nums[1], quando diferente interrompe o “loop” impedindo acesso fora do alocado. O ponteiro que tem o endereço de memória não alocado ainda não acessa esse local se não desreferenciar. Quase! Mas, use o especificado ("%p") designado para imprimir pointes e realize o cast para void *. Se ainda tem dúvida, pergunte. — Dica final: ative os alerta do compilador, lembre-se, ele foi/é desenvolvido com ajuda da Elite da Programação.

Essa expressão está correta? Sim porque a notação está correta, sabemos que notação de ponteiros é trocável por vetor. Um dublo ponteiro é o tipo que guardar o endereço de um ponteiro, se desreferenciar ele poderá ler seu conteúdo: o endereço de um ponteiro. Se declarar: int **ponteiros = (int * [4]) {NULL}; Alocará da pilha 4 ponteiros vizinhos (vetor de ponteiros) e atribuirá a 'ponteiros' o primeiro endereço. Se declarar: int *_0inteiros = (int [5]) {0}; int *_1inteiros = (int [5]) {1}; int *_2inteiros = (int [5]) {2}; int *_3inteiros = (int [5]) {3}; Alocará da pilha, sequencialmente, 4 vetores (int) e 4 ponteiros e atribuirá o endereço respectivamente. Agora tenho dois tipos derivados de int: 1 ponteiros e 4 inteiros, continue... ponteiros[0] = _0inteiros; ponteiros[1] = _1inteiros; ponteiros[2] = _2inteiros; ponteiros[3] = _3inteiros; Quando desreferenciar 'ponteiros' terá acesso a uma das 4 variáveis do vetor, no casso acima, é atribuído o endereço dos _Xinteiros de 0 á 3. Em seguida poderá gravar ou ler valores nas 'inteiros'. A assinatura [Y][X] acessa um dos endereços na '_Xinteiros' conforme os valore de Y, X e converte em variável do tipo int. Exemplo: #include <stdio.h> #include <stdlib.h> int main(){ int **ponteiros = (int * [4]) {NULL}; int *_0inteiros = (int [5]) {0,1,2,3,4}; int *_1inteiros = (int [5]) {1,2,3,4,5}; int *_2inteiros = (int [5]) {2,3,4,5,6}; int *_3inteiros = (int [5]) {3,4,5,6,7}; ponteiros[0] = _0inteiros; ponteiros[1] = _1inteiros; ponteiros[2] = _2inteiros; ponteiros[3] = _3inteiros; for(int i = 0; i < 4; ++i){ for(int j = 0; j < 5; ++j){ printf (" %d ", ponteiros[i][j]); } putchar('\n'); } printf("ponteiros[0][3]: %d\n", ponteiros[0][3]); } O mesmo exemplo e com argumento de função: #include <stdio.h> #include <stdlib.h> void print(int **m, int x, int y); int main(){ int **ponteiros = (int * [4]) {NULL}; int *_0inteiros = (int [5]) {0,1,2,3,4}; int *_1inteiros = (int [5]) {1,2,3,4,5}; int *_2inteiros = (int [5]) {2,3,4,5,6}; int *_3inteiros = (int [5]) {3,4,5,6,7}; ponteiros[0] = _0inteiros; ponteiros[1] = _1inteiros; ponteiros[2] = _2inteiros; ponteiros[3] = _3inteiros; print (ponteiros, 5, 4); printf("ponteiros[0][3]: %d\n", ponteiros[0][3]); } void print (int **m, int x, int y){ for(int i = 0; i < y; ++i){ for(int j = 0; j < x; ++j){ printf (" %d ", m[i][j]); } putchar('\n'); } return; } Observe o mesmo exemplo com uso da malloc #include <stdio.h> #include <stdlib.h> void print(int **m, int x, int y); int main(){ int **ponteiros = malloc (sizeof(int * [5])); int *_0inteiros = (int [5]) {0,1,2,3,4}; int *_1inteiros = (int [5]) {1,2,3,4,5}; int *_2inteiros = (int [5]) {2,3,4,5,6}; int *_3inteiros = (int [5]) {3,4,5,6,7}; ponteiros[0] = _0inteiros; ponteiros[1] = _1inteiros; ponteiros[2] = _2inteiros; ponteiros[3] = _3inteiros; print (ponteiros, 5, 4); printf("ponteiros[0][3]: %d\n", ponteiros[0][3]); free (ponteiros); } void print (int **m, int x, int y){ for(int i = 0; i < y; ++i){ for(int j = 0; j < x; ++j){ printf (" %d ", m[i][j]); } putchar('\n'); } return; } Ops! Algo deu errado. Os compiladores modernos são escritos por programadores de altíssimo desempenho só os melhores da categoria, PhD, engenheiros, homens e mulheres, jovens que se dedicaram/dedicam-se a Normal da Linguagem de Programação C, fazem esse excelente trabalho na implementação de rotinas de verificação de sintaxe, alimentadas com os erros/falhas mais comuns objetivando educar os seus adeptos com boas práticas. Nessa falha o compilador afirma que existe a hipótese' dereference '(desreferenciar) ponteiros NULL, de fato mesmo que pequena. Logo, é necessário verificar o retorno da malloc, ou ignorar o aviso! Mas, lembre-se que os compiladores são escritos por programadores que possuem a mais elevada prática da linguagem de programação. Logo... Vamos seguir o compilador, agora e sempre! #include <stdio.h> #include <stdlib.h> void print(int **m, int x, int y); int main(){ int **ponteiros = malloc (sizeof(int * [5])); if(ponteiros != NULL){ int *_0inteiros = (int [5]) {0,1,2,3,4}; int *_1inteiros = (int [5]) {1,2,3,4,5}; int *_2inteiros = (int [5]) {2,3,4,5,6}; int *_3inteiros = (int [5]) {3,4,5,6,7}; ponteiros[0] = _0inteiros; ponteiros[1] = _1inteiros; ponteiros[2] = _2inteiros; ponteiros[3] = _3inteiros; print(ponteiros, 5, 4); printf("ponteiros[0][3]: %d\n", ponteiros[0][3]); free(ponteiros); return 0; } puts("FAIL ponteiros es NULL!!!"); return 1; } void print(int **m, int x, int y){ for(int i = 0; i < y; ++i){ for(int j = 0; j < x; ++j){ printf (" %d ", m[i][j]); } putchar('\n'); } return; } Por fim, represento seu experimento, esse que tem na sua postagem original, e respondo todas as perguntas de uma só vez. #include <stdio.h> #include <stdlib.h> int main(){ int **ponteiros = malloc (sizeof(int * [5])); if(ponteiros != NULL){ int *_1inteiros = (int [5]) {1,2,3,4,5}; int *_2inteiros = NULL; _2inteiros = &_1inteiros[1]; free (ponteiros); ponteiros = &_2inteiros; (void)_2inteiros; printf("ponteiros[0][3]: %d\n", ponteiros[0][3]); return 0; } puts("FAIL es NULL"); return 1; } A variável tem valor 5 o experimento da expressão é SUCESSO! Essa expressão está correta? Sim! Esse ponteiro aponta para o endereço do ponteiro2 que aponta para o endereço do ponteiro1? Sim, os endereços são vizinhos (no vetor inteiros) Como eu faria para exibir essa expressão? Como escrevi! Se ainda tem dúvida, pergunte. [] — espero que ajude.

@ricardo_br Comendando abaixo de sua fala, Pois, sé -- o mercado mente -- a verdade é que interessa mais a pessoa (com excelência lógica e tecnológica) do que sua linguagem de estimação. Se existe um ponto de convergência das linguagens, eu acredito ser a lógica. Isto é, com uma boa lógica o céu é o limite. Não penso que C\C++ sejam complicadas se comparado a Python que figura com uma das linguagens mais recomendadas para um iniciante. Acredito que as apostilas e vídeos de Python são o seu segredo, por exemplo, JavaScript quase sempre foca na solução e linguagem é apenas um meio, assim como em python e raramente em C. Tem cada aberração de C, às vezes, a comunidade se expressa não como se fosse uma linguagem, mais sim uma língua. Negócio é ridículo