Pilha é uma estrutura de dados do tipo LIFO (Last In, First Out), muito importante e empregada na criação de algoritmos diversos, que funciona como uma coleção de elementos, permitindo acesso a somente um item de dados armazenado por vez – o último item inserido na estrutura (chamado de item do topo).

Esse item pode ser lido (acessado) ou removido da pilha.

É possível implementar pilhas de algumas formas, como por meio de arrays ou com o uso de ADTs (Abstract Data Types / Tipos de Dados Abstratos). Neste tutorial mostro como implementar uma pilha em C usando especificamente um array.

Para a implementação desta aplicação, faremos uso de várias estruturas importantes da linguagem C, incluindo cabeçalhos especiais, structs, ponteiros e, claro, arrays.

Uma pilha de livros. O último livro a ser colocado na pilha fica no topo, e é o primeiro a ser removido.

Vamos ao código da implementação.

Código: Pilha em C com Array

A seguir temos um exemplo de código que implementa uma pilha em linguagem C usando um array:

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

// Definir o tamanho máximo da pilha
#define TAM_MAX 100

// Definir a estrutura da pilha
struct pilha {
    int topo; // índice do topo da pilha
    int items[TAM_MAX]; // array para armazenar os itens da pilha
};

// Função que cria uma pilha vazia
struct pilha* criar_pilha() {
    struct pilha* nova_pilha = (struct pilha*) malloc(sizeof(struct pilha));
    nova_pilha->topo = -1;
    return nova_pilha;
}

// Função para verificar se a pilha está vazia
int is_empty(struct pilha* pilha) {
    return pilha->topo == -1;
}

// Função que verifica se a pilha está cheia
int is_full(struct pilha* pilha) {
    return pilha->topo == TAM_MAX - 1;
}

// Função para adicionar um item ao topo da pilha
void push(struct pilha* pilha, int item) {
    if (is_full(pilha)) {
        printf("Erro: a pilha está cheia.\n");
    }
    else {
        pilha->topo++;
        pilha->items[pilha->topo] = item;
    }
}

// Função para remover o item do topo da pilha
int pop(struct pilha* pilha) {
    if (is_empty(pilha)) {
        printf("Erro: a pilha está vazia.\n");
        return -1;
    }
    else {
        int item_removido = pilha->items[pilha->topo];
        pilha->topo--;
        return item_removido;
    }
}

// Função para retornar o item do topo da pilha sem removê-lo
int peek(struct pilha* pilha) {
    if (is_empty(pilha)) {
        printf("Erro: a pilha está vazia.\n");
        return -1;
    }
    else {
        return pilha->items[pilha->topo];
    }
}

int main()
{
    struct pilha* minha_pilha = criar_pilha();

    // Adicionar alguns itens à pilha
    push(minha_pilha, 10);
    push(minha_pilha, 20);
    push(minha_pilha, 30);
    push(minha_pilha, 40);

    // Mostrar o item atual do topo da pilha
    printf("Item atual do topo: %d\n", peek(minha_pilha));

    // Remover e imprimir o item do topo da pilha
    printf("Item removido: %d\n", pop(minha_pilha));

    // Mostrar o novo item atual do topo da pilha
    printf("Item atual do topo: %d\n", peek(minha_pilha));

    return 0;
}

Funcionamento

A estrutura de dados utilizada na implementação é definida através da estrutura pilha, que contém um inteiro topo que armazena o índice do elemento que está no topo da pilha e um array de nome items que armazena os elementos da pilha. A pilha tem um tamanho máximo definido pela constante TAM_MAX.

O código contém várias funções que operam na pilha. A função criar_pilha() aloca a memória necessária para a pilha e inicializa o topo da pilha com o valor -1. A função is_empty() verifica se a pilha está vazia, ou seja, se o topo da pilha é igual a -1.

A função is_full() verifica se a pilha está cheia, ou seja, se o topo da pilha é igual a TAM_MAX – 1. A função push() adiciona um elemento ao topo da pilha, verificando se a pilha está cheia antes de adicionar o elemento. A função pop() remove o elemento do topo da pilha, verificando se a pilha está vazia antes de remover o elemento.

A função peek() retorna o elemento atual do topo da pilha, mas sem removê-lo.

O programa principal começa alocando espaço para uma nova pilha chamada minha_pilha, utilizando a função criar_pilha(). Em seguida, o programa adiciona alguns elementos à pilha utilizando a função push().

Depois, o programa mostra o elemento atual do topo da pilha utilizando a função peek(). Então, o programa remove e imprime o elemento do topo da pilha utilizando a função pop().

Por fim, o programa mostra o novo elemento atual do topo da pilha utilizando a função peek().

Ao finalizar, o programa retorna o valor 0 para indicar que a execução foi concluída com sucesso.

Note que, para fins de simplicidade, neste exemplo eu usei um tamanho máximo fixo para a pilha (TAM_MAX), mas isso pode ser modificado para permitir pilhas de tamanho variável.

Conclusão

Neste artigo vimos como realizar uma implementação básica de pilha em linguagem C usando arrays. Nos próximos artigos estudaremos a implementação de outras estruturas de dados em C, empregando técnicas variadas, inclusive reaproveitando estruturas já criadas anteriormente – como as pilhas.

O post Como implementar uma pilha em linguagem C usando array apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em linguagem C, existem três tipos de estruturas de decisão condicional: if, if-else e switch-case. Essas estruturas são fundamentais para controlar o fluxo de execução do programa de acordo com condições específicas.

Condicional Simples: a estrutura if

A estrutura if permite executar um bloco de código somente se uma condição for verdadeira. A sintaxe é a seguinte:

if (condicao) {
  // bloco de codigo a ser executado se a condicao for verdadeira
}

Por exemplo:

int num = 5;
if (num > 0) {
  printf("O numero e positivo");
}
return 0;

Neste exemplo, se o valor da variável “num” for maior que zero, o bloco de código dentro do if será executado e a mensagem “O número é positivo” será exibida na tela.

Experimente alterar o valor de num para um número negativo, como -15, e rode novamente o programa. Neste caso, nada será exibido na tela, pois o teste condicional retornará “falso”, pulando a execução a instrução do bloco (printf)

Condicional composto: a estrutura if-else

A estrutura if-else permite executar um bloco de código se uma condição for verdadeira e outro bloco de código se a condição for falsa. A sintaxe é a seguinte:

if (condicao) {
  // bloco de codigo a ser executado se a condicao for verdadeira
} else {
  // bloco de codigo a ser executado se a condicao for falsa
}

Por exemplo:

int num = -3;
if (num > 0) {
  printf("O numero e positivo");
} else {
    printf("O numero e negativo");
}

Neste exemplo, se o valor da variável “num” for maior que zero, o bloco de código dentro do if será executado e a mensagem “O número é positivo” será exibida na tela. Caso contrário, o bloco de código dentro do else será executado e a mensagem “O número é negativo” será exibida na tela.

Condicional encadeado: a estrutura if – else if – else

A estrutura condicional if – else if – else é uma das formas mais comuns de controlar o fluxo de um programa em C, permitindo executar diferentes blocos de código dependendo de uma ou mais condições.

A seguir, apresento um tutorial passo a passo para entender e implementar a estrutura condicional if -else if- else em C:

O básico do if – else if – else

A estrutura do if – else if – else começa com a palavra-chave if, seguida de uma expressão entre parênteses que será avaliada como verdadeira ou falsa. Se a expressão for verdadeira, um bloco de código entre chaves {} será executado. Caso contrário, a execução passará para o próximo bloco de código else if, que seguirá o mesmo padrão.

O último bloco de código será sempre um else sem expressão, que será executado caso nenhuma das condições anteriores seja verdadeira.

if (condicao1) {
  // bloco de código a ser executado se a condicao1 for verdadeira
} else if (condicao2) {
  // bloco de código a ser executado se a condicao2 for verdadeira
} else if (condicao3) {
  // bloco de código a ser executado se a condicao3 for verdadeira
} else {
  // bloco de código a ser executado caso nenhuma das condições anteriores seja verdadeira
}
Exemplo de if - else if - else em ação

Vamos supor que temos uma variável idade e queremos imprimir uma mensagem de acordo com a faixa etária. Podemos usar a estrutura if – else if – else para isso:

int idade = 32;
if (idade < 18) {
  printf("Você é menor de idade");
} else if (idade >= 18 && idade <= 64) {
    printf("Você é adulto");
} else {
    printf("Você é idoso");
}

Nesse exemplo, a variável idade é igual a 32, então a expressão idade >= 18 && idade <= 64 é verdadeira, e o bloco de código correspondente ao else if é executado, imprimindo a string “Você é adulto” no console.

Dicas para usar o if-else if-else

• Lembre-se de colocar cada bloco de código entre chaves {} para garantir que apenas o código que você deseja seja executado em cada condição.
• Use o else para tratar casos que não foram tratados pelas condições anteriores.
• Lembre-se de que as expressões dentro dos if e else if devem ser avaliadas como verdadeiras ou falsas, e que operadores lógicos como && e || podem ser usados para combinar várias condições em uma expressão mais complexa.

A estrutura condicional switch-case

A estrutura condicional switch-case em linguagem C é uma forma de controlar o fluxo do programa com base em um valor específico. O switch é uma instrução que permite a comparação do valor de uma variável com várias possibilidades de valores, e cada possibilidade é associada a um bloco de código executável.

A seguir, apresento um tutorial passo a passo para entender e implementar a estrutura condicional switch-case em C:

O básico do switch-case

A estrutura do switch-case começa com a palavra-chave switch seguida por um valor ou uma expressão entre parênteses. Em seguida, é aberto um bloco de código entre chaves {}. O bloco é composto por várias instruções case, cada uma com um valor ou uma constante, seguida de dois pontos : e um bloco de código a ser executado caso o valor da expressão seja igual ao valor daquele case.

Cada bloco de código deve terminar com a palavra-chave break para evitar a execução dos blocos subsequentes.

switch (valor) {
case valor1:
  // bloco de código a ser executado quando o valor for igual a valor1
  break;
case valor2:
  // bloco de código a ser executado quando o valor for igual a valor2
  break;
// mais casos podem ser adicionados aqui
default:
  // bloco de código a ser executado caso nenhum dos casos anteriores seja verdadeiro
}

Exemplo de switch-case em ação

Vamos supor que temos uma variável diaDaSemana que representa o dia da semana (de 1 a 7), e queremos imprimir o nome do dia em português. Podemos usar a estrutura switch-case para isso:

int diaDaSemana = 3;
switch (diaDaSemana) {
  case 1:
    printf("Domingo");
    break;
  case 2:
    printf("Segunda-feira");
    break;
  case 3:
    printf("Terça-feira");
    break;
  case 4:
    printf("Quarta-feira");
    break;
  case 5:
    printf("Quinta-feira");
    break;
  case 6:
    printf("Sexta-feira");
    break;
  case 7:
    printf("Sábado");
    break;
  default:
    printf("Dia da semana inválido");
}

Nesse exemplo, o valor da variável diaDaSemana é 3, então o bloco de código correspondente ao case 3 é executado, e o resultado é a impressão da string “Terça-feira” no console.

Dicas para usar o switch-case

• Lembre-se de colocar a palavra-chave break após cada bloco de código dentro do switch, caso contrário, a execução continuará no bloco seguinte.
• Use o default para tratar casos que não foram tratados pelos casos anteriores.
• Não é possível comparar strings com o switch-case em C. Caso precise comparar strings, considere usar uma biblioteca como a string.h ou uma comparação de strings com um if-else encadeado.

É isso aí! Neste tutorial vimos como usar as estruturas de decisão condicional em linguagem C, incluindo os condicionais if /else e o switch/case.

O post Estruturas de Decisão Condicional em Linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Eis uma pergunta bastante interessante feita diversas vezes pelos assinantes do canal da Bóson Treinamentos no YouTube:

“Com tantas linguagens modernas e foco em Web, para que aprender uma linguagem tão antiga, difícil e com poucos recursos como a linguagem C?“

Será que é importante aprender C nos dias de hoje? Ou será perda de tempo? Vou tentar responder a essa pergunta neste artigo. Caso prefira ver (e ouvir) minha opinião em um vídeo, vá para o final do post e assista ao material postado no YouTube há algum tempo.

Um pouquinho de história da linguagem C

Primeiramente vamos entender de onde veio essa linguagem de programação. A linguagem C foi desenvolvida nos laboratórios Bell pelo cientista da computação Dennis Ritchie, no final de 1972, com o intuito de criar utilitários para rodar no sistema operacional Unix, que fora desenvolvido poucos anos antes. Acabou sendo usada para reescrever o próprio kernel do Unix na época (que havia sido criado originalmente na linguagem Assembly – pelo próprio Ritchie!).

Dennis Ritchie – o criador da Linguagem C e do sistema operacional Unix

Criada em 72? Realmente, a linguagem é antiga (em termos da ciência da computação). Porém, a linguagem é “atualizada” de tempos em tempos, com a implementação de alterações para melhorias e inclusão de novos recursos, e o padrão atual da linguagem é chamado de C17, publicado em dezembro de 2018, portanto é recente.

A linguagem está tão viva e bem que uma nova revisão do padrão será publicada a partir do final desse ano (prevista para dezembro de 2021), possivelmente no começo de 2022.

Certo. Então a linguagem, apesar de antiga, ainda é atualizada constantemente. Quais seriam então algumas de suas características principais?

Características da linguagem C

Vejamos algumas características técnicas da linguagem C. Ela é uma:

• Linguagem de propósito geral (pode ser empregada para desenvolver qualquer tipo de aplicação)
• Combina características de linguagens de alto nível com linguagens de baixo nível.
• Procedural e estruturada
• Emprega tipagem estática
• Fornece acesso de baixo nível à memória e outros recursos de hardware
• Possui estruturas para mapeamento de instruções em linguagem de máquina
• Faz uso extensivo de ponteiros
• Possui uma grande biblioteca de rotinas disponível
• Código contido em subrotinas – as chamadas funções (é estruturada).
• Suporta programação para interface gráfica
• É importante notar que C NÃO é uma linguagem orientada a objetos – para tal foi criada a linguagem C++, que traz esses recursos. Existem extensões que permitem que se usem recursos de orientação e objetos em C.

A linguagem C inspirou e deu origem a muitas das linguagens de programação existentes hoje, como: C++, C#, Go, Java, JavaScript, Julia, Python, Ruby, Rust e muitas outras.

Vantagens da linguagem C

Quais seriam as vantagens de usar C em relação a outras linguagens de programação mais modernas? Existem várias vantagens. A seguir destaco algumas delas:

• Velocidade. Como possui estruturas de acesso direto ao hardware, produz software extremamente rápido.
• Código compacto e portável para inúmeras plataformas (praticamente todas as existentes)
• Linguagem de propósito geral, usada para basicamente tudo: aplicações desktop, para servidores, bancos de dados, jogos, aplicações gráficas, programas para cálculos intensivos, computação científica, etc.
• Recomendada para desenvolvimento de sistemas embarcados e programação de microcontroladores, aplicações nas quais o tamanho do programa, gerenciamento dos recursos de hardware e tempo de resposta são cruciais.
• Amplamente recomendada para escrever aplicações que executem operações de baixo nível, como acesso direto à memória, registradores ou disco.
• Ótima linguagem para aprendizado de programação avançada, como estruturas de dados e técnicas gerenciamento de recursos, sendo comumente ensinada em cursos de nível superior.

Como desvantagens posso citar a curva de aprendizado, que pode se tornar íngreme conforme o estudante passa para níveis intermediário e avançado, e a dificuldade em se criar determinados tipos de aplicações, devido à ausência de bibliotecas especializadas para determinadas funções – o que não é um problema tão grave, se lembrarmos que a linguagem C, apesar de se uma linguagem de propósito geral, é recomendada para alguns nichos específicos na verdade – que veremos mais à frente.

Rankings de uso da linguagem C

E como está o uso da linguagem C hoje em dia? Vejamos alguns rankings:

De acordo com o Índice TIOBE, a linguagem C é a linguagem mais mepregada no mundo atualmente (julho / 2021):

Índice TIOBE de linguagens de programação – Julho de 2021

Outro ranking de linguagens importante, o índice PYPL, coloca a linguagem C como a 5ª mais usada no mundo, combinada com a linguagem C++: 

Índice PYPL de linguagens de programação – Julho de 2021

Apesar de esses rankings não serem estudos “oficiais”, eles servem para mostrar a preferência dos profissionais pelas diversas linguagens de programação existentes, e a alta procura pela linguagem C é um claro indicativo de sua importância nos dias de hoje, onde vem encontrando cada vez mais aplicação, principalmente nas áreas de microcontroladores, sistemas embarcados e Internet das Coisas.

Onde usamos a linguagem C

Onde eu posso usar C atualmente, afinal? Várias áreas da tecnologia se beneficiam do emprego de linguagem C no desenvolvimento de aplicações diversas. Entre elas podemos citar:

• Programação de sistemas, drivers e sistemas operacionais. Por exemplo, o kernel do Linux (e também do Windows, Android e iOS) é feito em C.
• Softwares para plataformas e ecossistemas diversos, desde supercomputadores a sistemas embarcados.
• Programação Web, usando CGI (Common Gateway Interface)
• Programação científica e com cálculo numérico
• Microcontroladores, como as plataformas Arduino, Texas Instruments, ST Microelectronics, e outras, e aplicações diversas para IoT (Internet of Things / Internet das Coisas)
• Construção de compiladores, bibliotecas e interpretadores para outras linguagens, como Python, PHP e Ruby, por exemplo.
• Criação de algoritmos para Machine Learning (Aprendizado de Máquina) e Inteligência Artificial.

Entre outras.

Conclusão

Vale a pena aprender e usar a linguagem C?

Sim, totalmente!

É uma das linguagens mais empregadas para desenvolvimento no mundo, e que continua a crescer ano a ano, principalmente por conta de novas aplicações que demandam código rápido, seguro e com baixa demanda de recursos, como é o caso dos sistemas embarcados, dispositivos para IoT e sistemas críticos, como controladores para aviônica e para equipamentos médicos.

Mas tenha em mente o seguinte: para cada problema, uma solução. A linguagem C não é apropriada em muitos casos, onde simplesmente existem linguagens muito mais simples, focadas e planejadas para um nicho específico.

E como aprender linguagem C?

No canal da Bóson Treinamentos no YouTube temos um curso básico de linguagem C, que eu recomendo, e que pode ser acessado por meio do link a seguir:

Curso de Linguagem C da Bóson Treinamentos

ou ainda ser assistido diretamente aqui:

Bibliografia

Livros também são uma das melhores formas de aprendizado de programação, e abaixo trago uma pequena bibliografia selecionada com alguns dos melhores livros que eu indico sobre programação em C:

Básico em C:

• Programando em C – Volume I – Fundamentos. Autor: Ulysses de Oliveira Editora: Ciência Moderna
• C Programming for the Absolute Beginner. Autor: Michael Vine. Editora: Thomson (em inglês)

C Avançado:

• Dominando Algoritmos com C. Autor: Kyle Loudon Editora: O´Reilly.

Do básico ao avançado em C (completo):

• C: Como Programar. Autores: Deitel & Deitel. Editora: Prentice Hall

Conteúdo do artigo em vídeo

Caso prefira, assista ao vídeo “Vale a pena aprender linguagem C atualmente?”:

O post Vale a pena aprender linguagem C atualmente (2012 / 2022)? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma string é um agrupamento de caracteres, como letras, números e símbolos. Em C, as strings são formadas e manipuladas com o emprego de várias estruturas, tais como arrays, funções e ponteiros.

Como criar e inicializar strings em C

Podemos criar e inicializar strings de várias maneiras em C. Por exemplo, podemos usar um array de caracteres mais um caractere NULL, para terminação da string. Veja o exemplo a seguir:

char nome[6] = {'F', 'a', 'b', 'i', 'o', '\0'};

O caractere NULL é representado pela sequência de escape \0 (\zero). Por conta desse caractere, o array criado terá 6 posições, em vez de 5, correspondentes aos caracteres armazenados.

A figura a seguir ilustra esse array de caracteres:

Outra forma de criar e inicializar uma string em C é usando uma cadeia de literais, ou string literal, que são agrupamentos de caracteres envolvidos em aspas, como podemos ver no exemplo a seguir:

char nome[] = "Fabio";

Quando atribuímos uma string literal a um array de caracteres, o número necessário de posições na memória é alocado automaticamente, incluindo o caractere de terminação NULL.

Strings e Ponteiros em C

As strings são implementadas como um ponteiro para um segmento de memória. Ou seja, o nome de uma string é na verdade um ponteiro que aponta para o endereço do primeiro caractere da string na memória.

Veja o exemplo a seguir.

char *nome = "Fabio";

Este código declara uma variável ponteiro e atribui a string literal “Fabio” para o primeiro local de memória (e seguintes) para onde a variável nome aponta. Ou seja, o ponteiro nome aponta para o primeiro caractere na string “Fabio”.

No exemplo a seguir, mostramos como uma string pode ser referenciada por meio de ponteiros, e manipulada como um array:

#include <stdio.h>
#include <locale.h>

int main (int) {

  setlocale(LC_ALL, "");
  char *nome = "Fabio";
  int x;
  printf("\nValor do ponteiro: %p\n", *nome);
  printf("\nO ponteiro aponta para: %s\n", nome);
  printf("\nOs endereços de memória de cada caractere são:\n");
  for (x=0; x<6; x++) {
    printf("%p\n",nome[x]);
  }
  for (x=0; x<6; x++) {
    printf("Valor: %c Endereço: %p\n", nome[x],nome[x]);
  }
  return 0;
}

Obs.: Em C, as strings não são identificadas como um tipo de dados. São apenas arrays de caracteres, ao contrário de outras linguagens, como C# ou Java, por exemplo, que implementam as strings como tipos de dados (de referência – classes, no caso).

Na próxima lição continuaremos o estudo de strings em linguagem C.

O post Introdução às Strings em Linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em nosso curso básico de linguagem C aqui no blog (e no canal do YouTube da Bóson Treinamentos) usamos o IDE Code::Blocks, que pode ser obtido no site www.codeblocks.org.
O Code::Blocks é um IDE open-source que suporta vários compiladores, incluindo o gcc, MinGW, Intel C++ e Visual C++, entre outros. Este editor é escrito em C++ e suporta as linguagens C, C++ e também Fortran.

O IDE Code::Block roda em sistemas Windows, Linux e Mac OS X, e já foi portado também para diversos outros sistemas operacionais como o FreeBSD, OpenBSD e Solaris, entre outros.

A instalação no Ubuntu Linux é extremamente simples, resumindo-se a um apt install básico. Vamos aos procedimentos:

Procedimentos de instalação do Code::Blocks

Primeiro, atualizamos a lista de pacotes do sistema:

$ sudo apt update

Vamos aproveitar e instalar um compilador no sistema, que será usado pelo Code::Blocks. Instalaremos o compilador g++, e assim poderemos usar o Code::Blocks para compilar também programas em C++. Digite o comando a seguir:

$ sudo apt install g++

E então instalamos o Code::Blocks:

$ sudo apt install codeblocks

Abrir o Code::Blocks e criar programa de teste

Após a instalação do IDE, vamos abri-lo para realizar suas configurações iniciais, e então escrever um programa de teste. Digite codeblocks no dash para abrir o programa:

Aparecerá uma tela de auto-detecção de compiladores. Selecione na lista o compilador a usar e clique em OK:

Aguarde enquanto o programa é aberto:

Temos agora a tela inicial do programa:

Vamos criar um novo projeto para testá-lo. Criaremos um programa que soma dois números e exibe o resultado na tela. Clique no menu File, New e então em Project…:

Na caixa de diálogo New from template, selecione o modelo Console application e clique em Go:

Será aberta a caixa de diálogo do assistente de nova aplicação. Clique em Next para prosseguir:

Na próxima tela, selecione a linguagem que será usada para programar. Usaremos a linguagem C. Clique em Next:

Na próxima tela, especifique um título para o projeto (usarei Soma-números) e uma pasta no disco para salvá-lo. Clique em Next:

Na próxima tela, escolha o compilador a ser usado no projeto (usaremos o GCC) e clique em Finish:

Projeto criado! Vamos agora digitar código. Expanda a pasta Sources na seção Management (lado esquerdo da tela) e dê duplo-clique no arquivo de código-fonte main.c:

O arquivo é aberto e já vem com um código de teste pronto – o famoso Hello World:

Na barra de ferramentas, clique no botão Build and Run para compilar e executar o código de teste:

Veja o programa em execução, mostrando a mensagem Hello World!:

Criar nosso próprio programa

Agora, vamos digitar o código a seguir no lugar do código do Hello World, para construirmos nossa aplicação de soma de dois números:

#include <stdio.h>
#include <stlib.h>
int main()
{
    int a,b;
    printf("Vamos somar dois números!\n");
    printf("Digite o primeiro número:\n");
    scanf("%d",&a);
    printf("Digite o segundo número:\n");
    scanf("%d",&b);
    printf("\n");
    printf("A soma de %d com %d é %d\n",a, b, a + b);
    return 0;
}

Na barra de ferramentas, clique no botão Build and Run para compilar e executar o código de nosso programa. Entre com os números como solicitado e pressione Enter para realizar o cálculo:

Perfeito! Code::Blocks instalado e testado com sucesso!

Opcionalmente, podemos testar o aplicativo a partir do terminal do Linux. Para tal, acesse a pasta onde o projeto foi salvo, entre no subdiretório ./bin/Debug e execute o aplicativo digitando ./Soma-numeros:

$ ./Soma-numeros

É isso aí! Até a próxima aula!

O post Como instalar o Code::Blocks no Ubuntu e criar um programa de teste em linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma Union é uma estrutura de dados em linguagem C que permite agrupar dados de tipos diferentes como um único objeto de dados. Unions são tipos de dados derivados, cujos membros compartilham o mesmo espaço de armazenamento.

Em diferentes situações em um programa, algumas variáveis podem ser importantes, ao passo que outras podem não ser relevantes, e uma union, por compartilhar o espaço entre suas variáveis internas acaba por economizar espaço de armazenamento.

Note que apenas um membro da union pode ser referenciado por vez.

Como Declarar Unions

A declaração de Unions em linguagem C é bem parecida com a declaração de uma estrutura (struct), como podemos ver a seguir:

union teste {
  int a;
  float b;
};

Neste exemplo declaramos uma union de nome teste, que é um tipo de dado contém dois membros: o campo a, para um valor inteiro, e o campo b, para armazenar um dado do tipo float. Uma union pode conter campos de qualquer tipo, incluindo structs e outras unions.

Ao declarar uma union, é possível inicializá-la, mas somente com um valor do mesmo tipo do primeiro membro contido na union.

Após criar o modelo da union, podemos criar variáveis baseadas nele usando a seguinte sintaxe:

union teste un01;

Criamos com esta declaração a variável un01, que é do tipo teste (union).

Como Acessar os membros da Union

Podemos acessar os membros de uma union usando o operador ponto (.). Por exemplo, vamos atribuir o valor 15 ao membro a da union teste, e logo após copiar seu valor deste membro para uma variável do programa:

int valor;
un01.a = 15;
valor = un01.a;
printf("Valor: %d", valor);

Com uma union somente pode conter valor em um membro por vez, se tentarmos atribuir valores a mais de um membro somente o último valor atribuido será realmente armazenado. Veja o seguinte exemplo:

union teste un01;

int valor;
un01.a = 15;
un01.b = 20.50;

printf("Valor do membro a: %d\n", un01.a);
printf("Valor do membro b: %f\n", un01.b);

A saída desse programa mostra o seguinte resultado:

Note que o valor do membro b está correto (20,50), porém o valor atribuído ao membro a (que é 15) não faz sentido algum. Agora veja o que ocorre se invertermos a ordem de atribuição, desta forma:

un01.b = 20.50;
un01.a = 15;

Agora o valor do membro a está correto, mas o do membro b está zerado. Isso mostra claramente que a union somente pode guardar valor em um de seus membros por vez. Se um membro possui valor armazenado, e é atribuído valor e um outro membro, o primeiro membro perde seu conteúdo.

Lembre-se sempre dessa propriedade das unions, pois isso pode causar problemas se não for levado em consideração em seus programas.

Operações em Unions

As operações que podems er realizadas em uma union são:

• Atribuir uma union a outra union do mesmo tipo
• Obter o endereço da union (&)
• Acessar seus membros com operadores adequados.

As unions não podem ser comparadas entre si (assim como as structs).

O post Unions em Linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Cada função da biblioteca padrão da linguagem C é declarada em um ou mais Cabeçalhos Padrão (“Standard Headers“, ou apenas “headers“). Estes contém também definições de tipos e macros que são fornecidas pela linguagem.

Os cabeçalhos padrão são conhecidos também como Arquivos de Cabeçalho, poiso conteúdo de cada cabeçalho é, no geral, armazenado em um arquivo, com a extensão .h.

A linguagem C padrão atual define 24 arquivos de cabeçalho padrão, listados a seguir:

Como usar os arquivos de cabeçalho

Adicionamos o conteúdo de um arquive de cabeçalho (header) a um arquivo de código-fonte usando a diretiva #include, preferencialmente incluída logo no início do arquivo.

Por exemplo, suponha que precisamos incluir funções matemáticas presentes no arquivo math.h em um programa. Para tal, usamos a declaração a seguir:

#include <math.h>

Note que não finalizamos a declaração com um ponto-e-vírgula (;). Essa declaração nos permitirá usar uma série de funções matemáticas definidas no cabeçalho math.h, de forma simples e eficiente.

Descrevendo os arquivos de cabeçalho

A seguir vamos descrever sucintamente cada um dos arquivos de cabeçalho listados na tabela anterior, e a partir do próximo artigo descreveremos também as funções, tipos e macros por eles definidas.

assert.h

Define a macro assert(), a qual testa se o valor de uma expressão é diferente de zero.

complex.h

Contém protótipos de funções matemáticas com números complexos e macros relacionadas

ctype.h

Este cabeçalho contém declarações de funções usadas para converter e classificar caracteres únicos.

errno.h

Declara o identificador errno para uso como uma variável de status com o tipo int. Várias funções configuram o errno para um valor que indica o tipo de erro encontrado durante a execução.

fenv.h

Contém todas as declarações que podem ser usadas ao acessar um ambiente de ponto-flutuante, o qual fornece variáveis de sistema que permitem que os programas lidem de forma simplificada e flexível com modos de controle e exceções de ponto flutuante.

float.h

Declara macros que descrevem a faixa de valores, a precisão, e outras propriedades dos tipos float, double e long double.

inttypes.h

Esse header inclui o cabeçalho stdint.h, e mais extensões dele. O cabeçalho stdint.h define os tipos inteiros com larguras de bits especificadas, incluindo os tipos intmax_t e uintmax_t, que representam os maiores tipos inteiros implementados.

iso646.h

Define onze macros que podem ser usadas como sinônimos para os operadores lógicos e bit a bit da linguagem C. As macros são:

limits.h

Contém macros que representam o menor e o maior valor representável em cada tipo inteiro.

locale.h

Este cabeçalho declara duas funções, setlocale() e localeconv(), a estrutura lconv, a macro NULL para constantes de ponteiro nulas, e as seguintes macros com nomes iniciados em LC_ para as categorias de informações de localização (locale):

• LC_ALL
• LC_COLLATE
• LC_CTYPE
• LC_MONETARY
• LC_NUMERIC
• LC_TIME

math.h

O cabeçalho math.h declara funções matemáticas para números de ponto-flutuante, e seus tipos e macros relacionados. (As funções matemáticas para números inteiros são declaradas em stdlib.h).

setjmp.h

Declara a função longjmp(), e define o tipo array jmp_buf, além da macro setjmp().

A função setjmp() salva o ambiente de execução atual, incluindo ao menos o registrador momentâneo e os valores da pilha, em uma variável de tipo jmp_buf. Assim, a função setjmp() marca um ponto no programa, para o qual se pode saltar a qualquer momento fazendo uma chamada à função longjmp().
Essas funções juntas permitem, desta forma, programar uma espécie de “goto” no programa.

signal.h

Esse cabeçalho declara as funções raise() e signal(), assim como macros relacionadas e o tipo inteiro sig_atomic_t.

Essas funções permitem tratar sinais por meio de um manipulador de sinais (signal handler). Um manipulador de sinais é uma função que é automaticamente executada quando o programa recebe um determinado sinal do ambiente do sistema operacional.

Cada tipo de sinal que os programas podem receber é identificado por um número de sinal. O cabeçalho signal.h define macros de tipo int que designam os tipos de sinais, sendo que a macros de tipo de sinal requeridas são as seguintes:

• SIGABRT
• SIGFPE
• SIGILL
• SIGINT
• SIGSEGV
• SIGTERM

Vamos explicar com detalhes o significado e aplicação dessas macros em um artigo específico.

stdarg.h

Define um tipo e quatro macros para uso no acesso a argumentos opcionais em funções que os suportam.

stdbool.h

Este cabeçalho define as seguintes macros:

• bool – Sinônimo para o tipo _Bool
• true – A constante de valor 1
• false – A constante de valor 0
• __bool_true_false_are_defined – A constante de valor 1

stddef.h

Este cabeçalho define três tipos e duas macros utilizadas em todos os tipos de programas. Os tipos são:

• ptrdiff_t – Tipo inteiro com sinal que representa a diferença entre dois ponteiros
• size_t – Tipo inteiro sem sinal usado para representar o resultado de operações sizeof.
• wchar_t – Tipo inteiro grande o suficiente para armazenar qualquer código no maior grupo de caractere estendido que a implementação suportar.

Além dos tipos citados, também são implementadas as duas macros seguintes:

• NULL – Representa uma constante de ponteiro nula.
• offsetof( tipo_estrutura, memb) – Fornece uma constante inteira com o tipo size_t cujo valor é o número de bytes entre o início de uma estrutura e o início de seu membro memb.

stdint.h

Cabeçalho que define tipos inteiros com tamanhos de bit específicos, e macros que indicam as faixas de valor desses e de outros tipos.

Vamos estudar o cabeçalho stdint.h com mais detalhes em outro artigo, devido à sua maior complexidade.

stdio.h

Contém declarações de todas as funções básicas para entrada e saída, assim com definições de tipos e macros relacionadas

Vamos estudar o cabeçalho stdio.h com mais detalhes em outro artigo, devido à sua maior complexidade.

stdlib.h

Cabeçalho que declara funções de utilidade geral para diversos propósitos, listados a seguir:

• Geração de números aleatórios
• Gerenciamento de memória
• Conversão de strings de números em valores numéricos binários
• Aritmética de números inteiros
• Busca e classificação
• Comunicação com o sistema operacional da máquina
• Conversão de caracteres multibyte para wide-characters (tipo caractere com tamanho maior que 8 bits; caracteres largos*)

Vamos estudar as funções, tipos e macros do cabeçalho stdlib.h com mais detalhes em outro artigo, devido à sua maior complexidade.

string.h

O cabeçalho string.h declara diversas funções para manipulação de strings, além de funções que operam em arrays de bytes.

Os nomes das funções aqui declaradas começam com str ou com mem, como as funções strcpy() e memcpy().

Além disso, esse cabeçalho também declara o tipo size_t e a macro NULL, que representa uma constante de ponteiro nula.

tgmath.h

Este cabeçalho inclui os cabeçalhos math.h e complex.h, e define macros de tipo genéricas.

time.h

Cabeçalho que declara funções padrão, tipos e macros para manipulação de informações de data e hora. Também declara quatro tipos:

• size_t – Tipo inteiro sem sinal usado para representar o resultado de operações sizeof.
• clock_t – Tipo aritmético retornado pela função clock()
• time_t – Tipo aritmético retornado pelas funções timer() e mktime()
• struct_tm – Os membros dessa estrutura representam uma data ou uma hora, divididas em segundos, minutos, horas, dia do mês, e assim por diante.

O cabeçalho time.h também define a macro CLOCKS_PER_SEC, que é uma expressão constante do tipo clock_t. Ela permite obter o tempo de uso da CPU pelo programa em segundos, dividindo-se o valor de retorno da função clock() por CLOCKS_PER_SEC.

wchar.h

O cabeçalho wchar.h declara funções para strings largas, que são strings de caracteres largos, do tipo wchar_t. Essas funções são similares às declaradas pelos cabeçalhos stdio.h, stdlib.h, string.h e time.h, que declaram funções para processamento de strings de caractere de um byte.

Além disso, o cabeçalho wchar.h também declara funções para realizar a conversão de caracteres multibyte* para caracteres largos*, e vice-versa.

wctype.h

Este cabeçalho declara funções para classificar e converter caracteres largos. Estas funções são análogas às funções para caracteres de byte declaradas no cabeçalho ctype.h. Além disso, também declara funções de conversão e classificação de caracteres largos extensíveis.

*Observações: 

Um caractere multibyte é um caractere composto por sequências de um ou mais bytes. Cada sequência de bytes representa um único caractere no conjunto de caracteres estendido. Os caracteres multibyte são usados nos conjuntos de caracteres como Kanji.

Os caracteres largos são códigos de caracteres multilíngues que sempre têm 16 bits de largura. O tipo para constantes de caractere é char; para caracteres largos, o tipo é wchar_t. Como os caracteres largos são sempre de tamanho fixo, usar caracteres largos simplifica a programação com conjuntos de caracteres internacionais.

Fonte: MSDN

O post Cabeçalhos Padrão – Standard Headers em Linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial de linguagem C vamos criar um pequeno programa que permite verificar se uma dada palavra, fornecida pelo usuário, é um palíndromo.

De acordo com a Wikipedia:

Um palíndromo é uma palavra, frase ou qualquer outra sequência de caracteres que tenha a propriedade de poder ser lida (de forma igual) tanto da direita para a esquerda como da esquerda para a direita. Num palíndromo, normalmente são desconsiderados os sinais ortográficos (diacríticos ou de pontuação), assim como o espaços entre palavras.

Ou seja, qualquer sequência de caracteres que seja a mesma se lida da esquerda para a direita ou da direita para a esquerda. Por exemplo, a palavra “osso” é um palíndromo, pois é idêntica não importa o sentido da leitura.

Para este algoritmo vamos fazer uso de algumas funções de manipulação de strings e importar bibliotecas específicas, como string.h e ctype.h. Vamos ao código.

Código

#include<stdio.h>
#include<string.h>
#include<locale.h>
#include <ctype.h>

int main() {
 setlocale(LC_ALL, "");
 int i, valor = 0;
 char palavra[15], inversa[15];

 printf("\nDigite uma palavra: ");
 gets(palavra);

 //Converter a palavra digitada para minúsculas
 for(i = 0; palavra[i]; i++){
   palavra[i] = tolower(palavra[i]);
 }

 //Copiar a palavra digitada para que seja invertida
 strcpy(inversa, palavra);

 //Inverter a palavra copiada
 strrev(inversa);

 valor = strcmp(palavra, inversa);

 if (valor == 0)
   printf("\nA palavra %s é palíndroma\n", palavra);
 else
   printf("\nA palavra %s não é palíndroma\n", palavra);

 return 0;
}

Crie um novo projeto em C e digite ou copie e cole o código anterior. Compile e execute o programa, fornecendo uma palavra como solicitado no console, e o programa retornará uma mensagem dizendo se a palavra é um palíndromo ou não, como ilustra a figura a seguir:

No meu exemplo, entre com a palavra “Mussum”, e o programa retornou a mensagem de que esta palavra é um palíndromo.

A seguir, vamos explicar sucintamente o funcionamento do código, assim como das funções empregadas em sua construção.

Funcionamento

• Cabeçalho string.h – A biblioteca string.h implementa um conjunto simples de funções para manipulação de strings, como funções para comparação e cópia de strings, entre outras. As funções strcpy e strcmp pertencem a esse cabeçalho.
• Cabeçalho ctype.h – O arquivo de cabeçalho ctrype.h implementa diversas funções úteis para manipulação de caracteres, como por exemplo funções para verificar se um caractere é ASCII ou para realizar conversões de maiúsculas para minúsculas e vice-versa. A função tolower pertence a essa biblioteca, assim como muitas outras (toupper, isalpha, isdigit, isspace, etc.).
• Função gets() – Lê a palavra digitada pelo usuário e a armazena na variável palavra.
• Função strcpy() – A função strcpy permite copiar uma string, usando a sintaxe strcpy(destino, origem). Em C, não podemos simplesmente atribuir o conteúdo de uma variável string a outra variável diretamente – devemos usar funções para tal.
• Função strrev() – A função strrev inverte uma string fornecida, de acordo com a sintaxe: strrev(variável_string).
• Função strcmp() – A função strcmp é usada para comparar duas strings e verificar se são iguais. Sua sintaxe é strcmp(str1, str2). Se ambas as strings forem iguais, um valor zero é retornado.
• Função tolower() – A função tolower permite converter caracteres em caixa alta para caixa baixa (minúsculas). Sua função inversa é a toupper.

Também é possível implementar esse programa sem a necessidade de usar a função strrev(), que não é padrão nas bibliotecas da linguagem C – em algumas implementações, ela pode não estar presente.

Nesse caso temos de criar nossa própria função para reversão da string, o que faremos na próxima lição.

Próximo: Criando função para inverter string e conferindo palíndromo em linguagem C

O post Verificando se uma palavra é um palíndromo em linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma Estrutura (Structure) em C é uma coleção de variáveis relacionadas, usando um nome comum. As estruturas em linguagem C podem conter variáveis de tipos diferentes de dados, ao contrário de um array, que só pode conter dados de um mesmo tipo.

As estruturas são usadas para definir registros que são armazenados em arquivos, e, juntamente com os ponteiros, simplificam a criação de estruturas de dados mais complexas, como por exemplo pilhas, listas ligadas, filas e árvores.

Definindo um modelo de Estrutura

As estruturas são um tipo de dados derivado, o que significa que são construídas com o uso de objetos de outros tipos existentes. Definimos um modelo de estrutura da forma como mostra a sintaxe seguinte:

struct identificador {
 tipo variável;
 tipo variável;
 tipo variável;
 tipo variável;
};

O exemplo a seguir mostra a definição de uma estrutura de nome endereco, contendo os membros rua, numero, CEP e bairro:

struct endereco {
 char rua[50];
 char numero[5];
 char CEP[8];
 char bairro[30];
};

A palavra-chave struct inicia o bloco de definição da estruturas. Logo após vem o nome que desejamos atribuir a ela (tag da estrutura), e então são abertas chaves { para iniciar a seção do corpo da estrutura. Note que nenhuma variável é realmente declarada com este comando – apenas definimos o formato dos dados da estrutura; basicamente, um tipo complexo de variável.

A figura a seguir ilustra a estrutura endereco, com suas variáveis-membro:

Fig. 1: Estrutura endereco na memória do sistema

No corpo da estrutura são definidas as variáveis (membros) do tipo structure, cada uma com seu próprio nome, sem repetições, e que podem ser de qualquer tipo básico de dados (int, float, char, etc.), ou ainda tipos de dados agregados, como arrays ou até mesmo outras estruturas – desde que não contenha uma instância de si mesma. É comum chamar os membros de elementos ou ainda campos.

Ao definirmos uma estrutura com um código como o mostrado acima, um novo tipo de dados será criado e poderá ser utilizado para declarar variáveis, sem no entanto ocupar espaço na memória ainda.

Declarando variáveis do tipo estrutura

Declaramos variáveis de um tipo estrutura da mesma forma que declaramos variáveis de outros tipos quaisquer. Por exemplo, vamos declarar a variável x para que seja do tipo struct endereco com a declaração a seguir:

struct endereco x;

Também é possível declarar uma ou mais variáveis durante a definição da própria estrutura. Por exemplo, podemos declarar três variáveis de nomes livro1, livro2 e livro3 a partir de uma estrutura de nome livro:

struct livro {
  char nome[30];
  char autor[50];
  int paginas;
  float preco;
} livro1, livro2, livro3;

Caso apenas uma variável do tipo estrutura seja necessária no programa, não precisamos  declarar um identificador, bastando definir o nome da variável que será criada. Por exemplo, podemos criar uma variável estrutura chamada livro da seguinte forma:

struct {
  char nome[30];
  char autor[50];
  int paginas;
  float preco;
} livro;

Operações em estruturas

Podemos realizar algumas operações em estruturas, listadas a seguir:

• Atribuir uma variável estrutura a outra variável estrutura do mesmo tipo
• Ler o endereço de uma variável estrutura
• Acessar os membros da estrutura
• Determinar o tamanho da estrutura com o operador sizeof.

Inicialização de estruturas

As estruturas podem ser inicializadas de várias formas:

1 – Usando uma lista de inicialização, como um array. Por exemplo, podemos inicializar a estrutura endereco usando a declaração a seguir:

struct endereco x = {"Av. Paulista", "1029", "05560-034", "Cerqueira César"};

Os elementos do array são passados aos membros da estrutura na ordem em que foram declarados.

2 – Atribuindo uma variável estrutura do mesmo tipo, já inicializada

3 – Atribuindo valores aos membros individuais da estrutura. Por exemplo, suponha que desejamos atribuir o valor “Av. Atlântica” ao membro rua da estrutura endereco. Podemos usar a declaração a seguir, referenciando o nome da variável estrutura, seguida por um ponto e pelo nome do membro (campo) que receberá a atribuição do dado:

endereco.rua = "Av. Atlântica";

Acessando os Membros de uma Estrutura

Usamos dois operadores para acessar os membros de uma estrutura: 

• Operador de Membro de Estrutura . (operador ponto)
• Operador de Ponteiro de Estrutura -> (operador seta)

Acessamos um membro de uma estrutura usando o operador ponto por meio do nome da estrutura, seguido por um ponto e pelo nome do membro que se quer acessar. Por exemplo, podemos acessar e visualizar o membro rua da estrutura x (endereco) usando a seguinte declaração:

printf("%s", x.rua);

Já com o operador de ponteiro de estrutura, o acesso é feito via um ponteiro para a estrutura. Por exemplo, suponha que um ponteiro xptr tenha sido declarado e aponte para a estrutura endereco, e que o endereço de uma estrutura x tenha sido atribuído ao ponteiro xprt. Para acessar o membro rua da estrutura endereco via operador de ponteiro usamos a declaração a seguir:

printf("%s", x->rua);

A instrução typedef

A instrução typedef permite criar aliases (apelidos / sinônimos) para tipos de dados definidos previamente. É muito comum usarmos typedef para definir nomes de tipos estrutura, pois assim conseguimos usar nomes mais curtos ao usar as estruturas no programa. Veja o exemplo a seguir:

typedef struct endereco Endereco;

Essa instrução define o tipo de nome Endereco  como sendo um sinônimo do tipo struct endereco. Também é possível usar typedef diretamente na declaração da estrutura, dispensando a necessidade de criar uma tag, como no exemplo a seguir:

typedef struct {
 char rua[40];
 char numero[5];
 char CEP[10];
 char bairro[30];
} Endereco;

Desta forma, podemos usar a palavra Endereco para declarar variáveis do tipo estrutura endereco que usamos anteriormente, como segue:

Endereco x;

Também podemos criar um array de estruturas:

Endereco x[20];

Neste caso, foi criado um array de nome x, contendo 20 estruturas do tipo Endereco.

Exemplo

No exemplo a seguir é declarada um modelo de estrutura de nome Endereco, usando a instrução typedef, e no código principal esse modelo é usado para declarar uma estrutura “x”, do tipo Endereco, a qual é inicializada na sequência.

O conteúdo de cada membro da estrutura é então mostrado na tela com o uso da instrução printf():

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

typedef struct {
 char rua[40];
 char numero[5];
 char CEP[10];
 char bairro[30];
} Endereco;

int main()
{
 setlocale(LC_ALL,"");

 Endereco x = {"Av. Paulista", "1029", "05560-034", "Cerqueira César"};
 printf("%s\n", x.rua);
 printf("%s\n", x.numero);
 printf("%s\n", x.CEP);
 printf("%s\n", x.bairro);

 return 0;
}

A imagem a seguir mostra o resultado da execução deste programa:

É isso aí! Na próxima lição vamos nos aprofundar no assunto de estruturas em linguagem C. Até!

O post Estruturas em linguagem C apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Podemos ter um ponteiro que aponte para um outro ponteiro, o qual por sua vez aponta para uma variável comum com um valor armazenado na memória.

Chamamos a essa técnica de Indireção Múltipla, ou ainda Ponteiros para Ponteiros, em contraste com a Indireção Simples, que ocorre quando um ponteiro aponta para uma variável diretamente.

Um ponteiro comum pode ser representado da seguinte forma:

Já um ponteiro para ponteiro pode ser representado assim:

Um ponteiro para ponteiro deve ser declarado de forma especial. Para isso, adicionamos mais um caractere * na frente do nome da variável ponteiro em sua declaração.

Veja o exemplo seguinte:

int **valor;

Essa declaração cria um ponteiro de nome valor, o qual irá apontar para outro ponteiro, o qual por sua vez aponta para uma variável do tipo int.

Atenção: neste exemplo, valor NÃO é um ponteiro para um número inteiro, e sim um ponteiro para um ponteiro de inteiro.

Acessando o valor apontado com indireção múltipla

Para acessar o valor final armazenado e apontado por um inteiro para ponteiro, usamos o operador ** também. Veja o exemplo a seguir:

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main()
{
 setlocale(LC_ALL, "");
 int a = 40;
 int *pont1;
 int **pont2;
 pont1 = &a;
 pont2 = &pont1;
 printf("O endereço da variável a é: %p\n", &a);
 printf("O endereço do ponteiro pont1 é: %p\n", &pont1);
 printf("O endereço do ponteiro pont2 é: %p\n", &pont2);
 printf("O endereço apontado por pont1 é %p\n", pont1);
 printf("O endereço apontado por pont2 é %p\n", pont2);
 printf("E o valor armazenado em a é: %d\n", **pont2);
 return 0;
}

Neste exemplo de código, criamos uma variável a, do tipo inteiro e cujo conteúdo é o número 40.

Também criamos dois ponteiros: pont1 e pont2. O ponteiro pont1 aponta para a variável a, ao passo que o ponteiro pont2 aponta para o ponteiro pont1.

Na sequência, exibimos na tela o conteúdo de a, seu endereço, e os endereços relacionados aos dois ponteiros criados, usando a função printf().

Veja o código em execução:

Ao executar o programa, vemos que o endereço da variável a é 0x0060FF0c, e que os endereços dos ponteiros pont1 e pont2 são 0x0060FF08 e 0x00FF04, respectivamente.

Vemos então que pont1 aponta para o endereço de final FF0C, que é o endereço da variável a, e que pont aponta para o endereço de final FF08, que é o endereço do ponteiro pont1. E ao lermos o conteúdo apontado por pont2, é mostrado o conteúdo da variável a (40), por meio da indireção múltipla.

Na próxima lição vamos tratar da Inicialização de Ponteiros.

Até!

Anterior: Aritmética de Ponteiros em C

O post Ponteiros em C – Indireção Múltipla apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.