Introdução à Programação C

Exemplo de um Programa

 // Exemplo de programa em C // Isto é uma linha de comentário void main() {     int a;            // declara a variável "a"    a = 3 + 2;        // soma 3 com 2 }

• Um programa em C é composto por um conjunto de Funções. A função pela qual o programa começa a ser executado chama-se main.
• Após cada cada comando em C deve-se colocar um ; (ponto-e-vírgula).
• Um programa em C deve ser Identado para que possa ser lido com mais facilidade.

Identificadores

São os nomes que podem ser dados para variáveis e funções.

Para a escolha destes nomes é necessário seguir alguams regras:

• Um identificador deve iniciar por uma letra ou por um "_" (underscore);
• A partir do segundo caracter pode conter letras, números e underscore;
• Deve-se usar nomes significativos dentro do contexto do programa;
• C é uma linguagem case-sensitive, ou seja, faz diferença entre nomes com letras maiúsculas e nomes com letras minúsculas.  Peso   e  peso são diferentes;
• Costuma-se usar maiúsculas e minúsculas para separar palavras: "PesoDoCarro";
• Deve ser diferente dos comandos da linguagem;
• Deve ter no máximo 31 caracteres (no caso do TurboC);
• Pode conter números a partir do segundo caracter;
• Exemplos:

Idade, Contador, PesoDoCarro,
Usuario_1, CorDaPagina, RaioDoCirculo

Variáveis

Uma variável é uma possição de memória que pode ser identificada através de um nome.

Podem ter seu conteúdo alterado por um comando de atribuição.

Após a atribuição mudam de valor.

 int a,b, SomaGeral;

 a = 3; // a recebe o valor 3

 b = a * 2; // b recebe o dobro do valor de a 

 c = a + b + 2; // c recebe 11

Tipos de Variáveis

• Todas as variáveis em C tem um tipo;
• Cada tipo define os valores que a variável pode armazenar;
• Cada tipo ocupa uma certa quantidade de nemória.

Declaração de Variáveis

• Todas as variáveis tem que ser declaradas antes de serem usadas;
• Não há uma inicialização implícita na declaração

 // Exemplo de programa em C  #include <stdio.h>   //  Arquivo de cabeçalho (header) void main() {     int contador;            // declarações simples    float PrecoDoQuilo;    double TaxaDeCambio;    char LetraDigitada;    int IdadeManoel, IdadeJoao, IdadeMaria;  // Pode colocar mais de uma variável na  					    // na mesma linha

    double  TaxaDoDolar,            TaxaDoMarco,            TaxaDoPeso,        // Também pode trocar de linha no meio            TaxaDoFranco;        

 .......   }

Inicialização de Variáveis na Declaração

 // Exemplo de programa em C  #include <stdio.h>   //  Arquivo de cabeçalho (header) void main() {     int NroDeHoras = 0;            // declara e inicializa com Zero    float PrecoDoQuilo = 10.53;    // declara e inicializa com 10.53
   double  TaxaDoDolar = 1.8,
           TaxaDoMarco = 1.956,
           TaxaDoPeso = 1.75,        
           TaxaDoFranco = 0.2;        

 .......   }

Constantes

Constantes são identificadores que não podem ter seus valores alterados durante a execução do programa.

Para criar uma constante existe o comando #define que, em geral é colocado no início do programa-fonte.

Exemplos

 #define LARGURA_MAXIMA 50           // Não se coloca ponto-e-vírgula após o valor #define NRO_DE_DIAS_DA_SEMANA 7 #define NRO_DE_HORAS_DO_DIA 24 #define VALOR_DE_PI  3.1415

 void main () {    int TotalDeHoras;      TotalDeHoras = 10 * NRO_DE_DIAS_DA_SEMANA * NRO_DE_HORAS_DO_DIA; ...... } 

Strings

Uma String é uma seqüência de caracteres entre aspas duplas: "exemplo de uma string em C".

A função printf

A função printf exibe um ou mais dados na tela. Para tanto ele deve receber pelo menos dois parâmetros, separados por vírgula:

• um string de formato que define, através de caracteres especiais, os tipos dos dados a serem impressos e suas posições na linha de impressão;
• um dado a ser impresso. Este dado pode ser qualquer um dos dados visto anteriormente.

Por exemplo:

printf("%s","teste");

"%s" : é a string de formato
"teste" : é o dado a ser impresso.

A string de formato define quais os tipos dos dados a serem impressos. O símbolo %s será substituído pelo dado que vem após a vírgula.
Os dados definem quais os valores a serem impressos.

Se for  necessário, um string de formato pode definir que mais de um dado será impresso. Para tanto, dentro da string de formato deve haver mais de um %, um para cada dado a ser impresso.
Neste caso, os dados devem vir após a string de formato separados por vírgulas.

Por exemplo:

printf("%s %s","teste1", "outra string");

Isto irá imprimir o string teste1 deixar 1 espaço em branco e imprimir ao lado o string outra string, assim :

teste1 outra string

 #include <stdio.h>  	// Necessário para usar a função printf 			// A função printf exibe um ou mais dados na tela

 void main () {    printf("%s","Isto é uma string ....\n"); // note o '\n' no final da string;    printf("%s","Outra string ....");     printf("%s","Terceira string\n"); 

 //Depois de Executar o programa, tecle ALT-F5 para ver o resultado na tela } 

Exercício

Experimente colocar um '\n' entre os %s na string de formato.

printf("%s\n%s","teste1", "outra string");

Inclusão de Texto na String de Formato

É possível incluir um texto dentro da string de formato. Este texto irá aparecer exatamente como for digitado no programa-fonte.

O exemplo
            printf("A aluna %s ficou doente","Maria");
geraria

A aluna Maria ficou doente

como resultado.

Constantes do tipo String

 #define UNIVERSIDADE "Pontifícia Universidade Católica do Rio Grande do Sul" 	// deve-se colocar entre aspas

 #include <sdtio.h> #include <conio.h>   // necessário para as funções clrscr e getch

 void main () {    clrscr();     // Limpa a tela    printf("%s", UNIVERSIDADE); // Imprime o nome representado pela constante    getch();      // espera que o usuário pressione uma tecla } 

Impressão de Inteiros com "printf"

Para imprimir um inteiro com printf usa-se o símbolo %d

 // Impressão de Variáveis Inteiras #include <stdio.h> #include <conio.h>   // necessário para as funções clrscr e getch

 void main () {    int Contador;    int NroDeFilhos;        clrscr();     // Limpa a tela     Contador = 10;    printf("Valor da Variável: %d\n", Contador); 	// No momento da execução sinal %d vai   					      	// ser substituído pelo valor da  					      	// variável Contador

    NroDeFilhos = 3;    printf("Maria tem %d filhos", NroDeFilhos); 	// o inteiro pode ficar no meio da string

    getch();      // espera que o usuário pressione uma tecla } 

Impressão de Expressões aritméticas

 // Impressão de Expressões aritméticas #include <stdio.h> #include <conio.h>   // necessário para as funções clrscr e getch

 void main () {    int NroDeAndares;    int AlturaPorAndar;        clrscr();     // Limpa a tela

    NroDeAndares = 7;    AlturaPorAndar = 3;     printf("Altura Total do Prédio: %d metros", NroDeAndares*AlturaPorAndar);  	// No momento da execução sinal %d vai ser substituído  	// pelo valor da multiplicação

    getch();      // espera que o usuário pressione uma tecla } 

Impressão de Números reais

 // Impressão de números reais #include <stdio.h> #include <conio.h>   // necessário para as funções clrscr e getch

 void main () {    float NotaDaP1, NotaDaP2;    float Media;            clrscr();     // Limpa a tela

    NotaDaP1 = 6.6;  // Atribuição do Valores das médias    NotaDaP2 = 8.2;     Media = (NotaDaP1 + NotaDaP2) / 2.0;     printf("Média Final : %f", Media);  	// No momento da execução sinal %f vai ser substituído  	// pelo valor da variável Media com SEIS casas decimais         // Média Final : 7.400000    getch();      // espera que o usuário pressione uma tecla } 

Formato de Impressão dos Números Reais

No exemplo acima o resultado da média (7.4) foi impresso com 6 casas decimais (7.400000).

Isto sempre acontece quando se manda imprimir um float da forma como foi feito no exemplo acima. Isto acontece pois o padrão da função printf é completar o número com zeros à direita, até que fique com seis casas decimais.

Para formatar de maneira diferente usar-se, junto com o %f uma especificação de quantas casas decimais se deseja que o número tenha. Especifica-se também o número total de caracteres do número a ser impresso.

Por exemplo:    %6.3f   especifica que se quer imprimir um float com 3 casas decimais e com um tamanho total de  6 caracteres no total.

 #include <stdio.h> #include <conio.h>

 void main() {    float NotaDaP1, NotaDaP2;    float Media;      clrscr();     // Limpa a tela

    NotaDaP1 = 6.6;  // Atribuição do Valores das médias    NotaDaP2 = 8.2;     Media = (NotaDaP1 + NotaDaP2) / 2.0;     printf("Média Final : %6.3f", Media);  	// No momento da execução sinal %6.3f vai ser substituído  	// pelo valor da variável Media         // Média Final :  7.400

    getch();      // espera que o usuário pressione uma tecla     }

Regras para impressão de um número real

• o número de casas decimais é sempre respeitado. Se for preciso, zeros serão acrescetados à direita do número
• o tamanho total significa o número de caracteres do número incluíndo o ponto decimal e um eventual sinal de
  menos (-), se for o caso;
• Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais a parte fracionária, mais um eventual sinal de menos ainda for menor do que o tamanho total especificado no formato, então, espaços em branco serão acrescentados à esquerda da parte real do número.
• Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais a parte fracionária, mais um eventual sinal de menos for maior do que o tamanho total especificado no formato, então, apenas o número de casas decimais é respeitado

Por exemplo:

 #include <stdio.h> #include <conio.h> void main() {    float Numero;    Numero = -2.5;    clrscr();    printf("1234567890\n");    printf("%7f\n", Numero);    printf("%7.0f\n", Numero);    printf("%7.3f\n", Numero);    printf("%8.3f\n", Numero);    printf("%9.3f\n", Numero);    printf("\n");    printf("%8.4f\n", Numero);    printf("%8.1f\n", Numero);    printf("%6.12f\n", Numero);     getch(); }  // Resultados

 1234567890 -2.500000      -2  -2.500   -2.500    -2.500   -2.5000     -2.5 -2.500000000000 

Alinhamento de números à DIREITA

Nos exemplos anteriores os números ficavam sempre alinhados a partir da esquerda.
Experimente colocar um sinal de menos logo depois do sinal de % e veja o que acontece.

 printf("%-7.3f\n", Numero); 

Variáveis do Tipo String

Uma variável capaz de arrmazenar uma string deve ser declarada informando-se qual o número máximo de caracteres que ela poderá armazenar.

Exemplo:
        char Nome[30];  // isto define que a variável poderá armazenar uma 
                     	// string de até 29 caracteres.

Ao trabalharmos com strings deve-se incluir o arquivo de cabeçalho string.h

Atribuição com strings

As atribuições de valores a strings devem ser feitas através da   função strcpy

 // Exemplo com strings

 #include <stdio.h> #include <conio.h> #include <string.h>  // arquivo de cabeçalho para trabalhar com strings  void main() {    char Nome[30];  // declara uma string que poderá armazenar até 29 caracteres !! 

    clsrscr();

    strcpy(Nome, "Jose da Silva");  // atribui "Jose da Silva" para a variável Nome    printf("O funcionário %s foi tranferido", Nome);  // no lugar de %s aparecerá o  						     // conteúdo da variável Nome      

    getch(); } 

Operadores Aritméticos

 -

 sinal de menos (unário)

 Maior precedência (avaliado antes)

 *,/

 multiplicação e divisão

 %

 módulo (reto da divisão)

 +,-

 soma e subtração

 Menor precedência (avaliado depois)

Pode-se usar parênteses para alterar a precedência.

Exercício

Crie um progama que organize os dados em uma tabela conforme o exemplo a seguir. Os dados das células em amarelo deve ser informados através de atribuições dentro do programa.

Procure usar somente os %f para definir o formato e a posição dos dados.
Não tente preencher os espaços com brancos. Por exemplo, use

printf ("%10d, QuantidadeDeBananas);

ou invés de

printf("          %d", QuantidadeDeBananas);

O programa em C mínimo

O mais curto programa em C que é possível escrever é o seguinte:

main()
}
{

É equivalente ao seguinte programa em PASCAL:

Program Minimum;
begin
end.

Todo o programa em C deverá conter uma e só uma função main().
As chavetas { e } agrupam instruções, sendo equivalentes às palavras chave begin e end do PASCAL.
É possível colocar comentários em qualquer posição de um programa em C. Um comentário é qualquer texto delimitado pelos caracteres /* e */. Por exemplo:

/* O meu primeiro programa em C */
main()
{
     /* Outro comentário */
}

Os comentários não podem ser imbricados. Assim, o exemplo seguinte:

/* O meu primeiro programa em C */
main()
{
     /* Comentário /* Mais um comentário */ */
     /* Ilegal */
}

… é ilegal.
 

Um programa mínimo mais útil

O seguinte programa produz uma saída, escrevendo algum texto no vídeo:

main()
{
  printf("Hello world!\n");
  exit(0);
}

printf e exit são funções que existem na biblioteca standard da linguagem C. Veremos o que fazem mais tarde.
 

Criação, compilação e execução de um programa

Os estados de desenvolvimento de um programa em C são geralmente os três que constam do título desta secção, ou seja:

• Criação do programa fonte (texto)
• Compilação desse programa, para a sua tradução para código executável
• Execução do código produzido

No caso da detecção de qualquer erro em qualquer dos estados, todos eles deverão ser repetidos desde o início.

Criação do programa

A criação dos programas fonte em linguagem C faz-se com o auxílio de um editor de texto genérico, ou específico de um ambiente de desenvolvimento. Em geral, os arquivos de texto produzidos deverão ter a extensão .c, para poderem ser reconhecidos automaticamente pelo compilador como sendo arquivos contendo código fonte em C. Obviamente o conteúdo dos arquivos deverá verificar rigorosamente a sintaxe da linguagem C.

Compilação

A compilação dos programas em C faz-se através da invocação de um compilador (p. ex. no UNIX, o comando cc). O comando de compilação deverá ser seguido pelo nome do arquivo que contém o código fonte (geralmente com a extensão .c). É também comum colocar como parâmetros de chamada do compilador, várias opções de compilação (p. ex. no UNIX, a indicação do nome do arquivo executável com o resultado da compilação).

Assim uma compilação básica poderia ser executada no UNIX através do comando:

cc program.c

onde program.c é o nome do arquivo contendo o código fonte.

Se existirem erros de sintaxe no código fonte, o compilador detecta-los-á e indicará a sua localização junto com uma breve descrição do erro. Erros na lógica do programa apenas poderão ser detectados durante a execução do mesmo. Se o programa não contiver erros de sintaxe o compilador produzirá código executável. Tratando-se de um programa completo o código executável é colocado, por defeito, num arquivo chamado a.out (isto no UNIX). Se se pretender colocar o resultado da compilação noutro arquivo deverá utilizar-se a opção -o:

cc -o program program.c

Neste caso o código executável é colocado no arquivo program que é já criado com os necessários direitos de execução (no UNIX).

Execução do programa

Se a operação anterior tiver sucesso, a execução do programa compilado produzido faz-se simplesmente invocando-o como se fosse um comando do sistema operativo.

Durante a execução podem tornar-se evidentes mais alguns erros: erros de execução (p. ex. divisão por zero), ou erros que levem a que o programa não se comporte como esperado. Neste caso é necessário voltar à edição do programa fonte para corrigir a sua lógica, e depois efectuar também uma nova compilação para produzir a nova versão do código executável.
 

O modelo de compilação da linguagem C

Salientaremos aqui apenas os pontos principais do modelo de compilação da linguagem C.
Esse modelo pode ser ilustrado através da figura seguinte.

O pré-processador

O pré-processador será estudado em maior detalhe mais tarde. Contudo iremos adiantar alguma informação mais básica agora.
O pré-processador actua apenas ao nível do código fonte, modificando-o. Trabalha apenas com texto. Algumas das suas funções são:

• remover os comentários de um programa;
• interpretar directivas especiais a si dirigidas, que começam pelo carácter #.

Por exemplo:

• #include - insere o conteúdo de um arquivo de texto no arquivo corrente. Esses arquivos são usualmente designados por cabeçalhos (header files) e têm a extensão .h:
  • #include <math.h> - Insere o conteúdo do arquivo math.h com a declaração das funções matemáticas da biblioteca standard.
  • #include <stdio.h> - Idem para as funções standard de entrada/saída.
• #define - define um nome simbólico cujas ocorrências no arquivo serão substituídas por outro nome ou constante:
  • #define MAX_ARRAY_SIZE 100 - substitui todas as ocorrências de MAX_ARRAY_SIZE por 100.

O compilador

Alguns compiladores traduzem o código fonte (texto) recebido do pré-processador para linguagem assembly (também texto). No entanto são também vulgares os compiladores capazes de gerarem directamente código objecto (instruções do processador já em código binário).

O assembler

O assembler traduz código em linguagem assembly (texto) para código objecto. Pode estar integrado no compilador. O código objecto é geralmente armazenado em arquivos com a extensão .o (unix) ou .obj (ms-dos).

O linker

Se o programa referencia funções da biblioteca standard ou outras funções contidas em arquivos com código fonte diferentes do principal (que contém a função main() ), o linker combina todos os objectos com o resultado compilado dessas funções num único arquivo com código executável. As referências a variáveis globais externas também são resolvidas pelo linker. Mais pormenores mais tarde.

A utilização de bibliotecas

A linguagem C é muito compacta. Muitas das funções que fazem parte de outras linguagens não estão directamente incluídas na linguagem C. Temos como exemplo as operações de entrada/saída, a manipulação de strings e certas operações matemáticas.

A funcionalidade correspondente a estas e outras operações não faz parte integrante da linguagem, mas está incluída numa biblioteca externa, bastante rica e standard. Todas essas operações são executadas por via da invocação de funções externas definidas nessa biblioteca standard. Num dos últimos capítulos serão fornecidos detalhes acerca de algumas das funções da biblioteca standard do C.

Qualquer programador poderá desenvolver a sua própria biblioteca de funções, podendo até substituir algumas das funções standard, e também utilizar outras bibliotecas comerciais já existentes (p. ex. NAG, PHIGS, etc).
 

Características da linguagem C

Algumas das características do C que levaram a que se tornasse uma das mais populares linguagens de programação, são:

• Pequeno tamanho da sua definição
• Subdivisão do código e grande utilização de funções
• Alguma conversão automática entre tipos de dados (ao contrário do Pascal)
• Linguagem estruturada
• Disponibilidade de operadores para programação de baixo nível
• Utilização fácil e extensa de apontadores para aceder memória, vectores, estruturas e funções

Algumas das razões que tornaram o C uma das linguagens predilectas dos programadores profissionais são:

• A possibilidade de usar construções de alto nível
• A possibilidade de utilizar operadores de baixo nível
• A produção de código executável eficiente
• A disponibilidade de compiladores em praticamente todos os sistemas de computação

Neste momento todos os compiladores seguem o standard internacional conhecido por ANSI C (American National Standards Institute).
 

Marcos históricos

• 1969 - Desenvolvimento do UNIX (num PDP 7 em linguagem Assembly)
• 1969 - Desenvolvimento da linguagem BCPL, próxima do Assembly
• 1970 - Desenvolvimento da linguagem B, sucessora da anterior (o B é a 1ª letra de BCPL)
• 1971 - Primeiro desenvolvimento da linguagem C, sucessora da anterior (o C é a 2ª letra de BCPL)
• 1973 - O sistema operativo UNIX é reescrito em linguagem C
• 1978 - Primeira edição do livro The C Programming Language, Kernighan & Ritchie
• 1983-1988 - Definição do ANSI C

Exercícios

1. Crie, compile e execute o seguinte programa em C:

void main(void)
{
  int i;
  printf("\t Número \t\t Quadrado\n");
  for (i=0; i<=25; ++i)
    printf("\t %d \t\t %d\n", i, i*i);
}

2. Crie um programa em C que escreva no vídeo o seu nome e endereço.
 

jogosdia.webnode.com.br

#include <iostream>
#include "stdlib.h"
#include <ctime>



using namespace std;


int rollDice(void); //protótipo da função

int main()
{
enum Status {CONTINUE, VENCEU, PERDEU};
int soma, meuPonto;
Status gameStatus;

srand (time (0));
soma = rollDice(); //primeiro lançamento dos dados

switch (soma)
{
case 7:
case 11:
gameStatus = VENCEU;
break;
case 2:
case 3:
case 12:
gameStatus = PERDEU;
break;
default:
gameStatus = CONTINUE;
meuPonto = soma;
cout << "Ponto é " << meuPonto << endl;
break;
}

while (gameStatus == CONTINUE)
{
soma = rollDice();

if (soma == meuPonto)
gameStatus = VENCEU;
else
if
(soma == 7)
gameStatus = PERDEU;
}

if (gameStatus = VENCEU)
cout << "Jogador GANHA" << endl;
else
cout << "Jogador PERDE" << endl;

return 0;


}

int RollDice(void)
{
int die1, die2, workSum;

die1 = 1 + rand() % 6;
die2 = 1 + rand() % 6;
workSum = die1 + die2;
cout << "Jogador fez " << die1 << " + " << die2 << " = " << workSum << endl;

            Programacao de computadores de linguagem c

Programacao de computadores

#include <stdio.h>   struct pessoa  {    unsigned short int idade;    char nome[51]; /* vetor de 51 chars para o nome */    unsigned long int rg; }; /* estrutura declarada */   int main(void) {    struct pessoa exemplo = {16, "Fulano", 123456789}; /* declaração de uma variável tipo struct pessoa */      printf("Idade: %hu\n", exemplo.idade);    printf("Nome: %s\n", exemplo.nome);    printf("RG: %lu\n", exemplo.rg);   int main() {    printf("Olá, Mundo!\n")clude <stdio.h> /* Pacotes com funções de entrada e saída */ #include <math.h> /* Este pacote é desnecessário, mas mostra que podem ser adicionados outros pacotes */   int main(void) {    printf("Olá, Mundo!\n");    return 0; /* Retorna 0, pois main retorna um int */ } /* Nova linha após fechar a chave principal */    return 0; } int main (int argc, char ** argv)  int main (int argc, char * argv[]) #include <stdio.h>   int main() {    int a = 3, b = 7;      printf("a + b = %d\n", a+b);   stdio.h>   int main() {    int x, y; //define duas variáveis      printf("x = ");     scanf("%d", &x); //scanf atribui o valor digitado a x      printf("y = ");    scanf("%d", &y); //scanf atribui o valor digitado a y      printf("x + y = %d\n", x+y); //printf mostra na tela o resultado.   stdio.h>   int main() {    int x, y; //define duas variáveis      printf("x = ");     scanf("%d", &x); //scanf atribui o valor digitado a x      printf("y = ");    scanf("%d", &y); //scanf atribui o valor digitado a y      printf("x + y = %d\n", x+y); //printf mostra na tela o resultado.      return 0; }    return 0; }    return 0; }  

Programacao de linguagem c++

Tipos de dados

C tem um sistema de tipos semelhante ao de alguns descendentes da linguagem ALGOL, tais como Pascal. Possui tipos para números inteiros de vários tamanhos com e sem sinal, números de ponto flutuante, caracteres e estruturas (structs). C usa extensivamente ponteiros, um tipo muito simples de referência que guarda o endereço de memória da variável. O ponteiro pode ser desreferenciado, uma operação que busca o objecto que se encontra na morada da memória que o ponteiro possui, morada essa que pode ser manipulada através de aritmética de ponteiros. Durante o tempo de execução, o ponteiro é simplesmente uma morada de máquina tais como aquelas manipuladas em Assembly, mas em tempo de compilação possui um tipo complexo que indica o tipo do objecto para onde ele aponta, permitindo que se verifique o tipo de expressões, incluindo ponteiros. Os ponteiros são usados extensivamente em C. O tipo linha de texto de C é simplesmente um ponteiro para um vetor de caracteres e alocação dinâmica de memória, descrita abaixo, é efectuada através de ponteiros.

Os ponteiros em C possuem um valor reservado especial, NULL, que indica que não estão a apontar para uma morada. O uso desse valor como morada é muito útil na construção de várias estruturas de dados, mas causa comportamento não-definido (possivelmente uma falha de sistema) ao ser desreferenciado. Um ponteiro que possui o valor NULL é chamado ponteiro nulo. Os ponteiros são declarados (e desreferenciados) com um * (asterisco), portanto o tipo int* denota um ponteiro para número(s) inteiro(s). A linguagem C também fornece um tipo especial de ponteiros, o void*, que se traduz num ponteiro que aponta para um objecto de tipo desconhecido.

A linguagem C também tem apoio a nível de linguagem para vetores estáticas (de dimensão fixa) de tipos. As disposições de tipos podem parecer ter mais que uma dimensão apesar de serem tecnicamente disposições de disposições de tipos. Em memória, tais estruturas são posicionadas com as linhas uma depois da outra (a alternativa seria armazenar os dados em colunas, usado em outras linguagens). O acesso a disposições de tipos é feito através de ponteiros e aritmética de ponteiros; o nome da disposição é tratado como se fosse um ponteiro que aponta para o início da disposição. Em certas aplicações não é razoável usarem-se disposições de tipos de dimensão fixa e por isso a alocação dinâmica de memória pode ser usada para criar disposições de tipos de dimensão variável.

Como a linguagem C é regularmente usada em programação de baixo-nível de sistemas, há casos em que é necessário tratar um número inteiro como sendo um ponteiro, um número de ponto flutuante como sendo um número inteiro ou um tipo de ponteiro como sendo outro. Para estes casos, a linguagem C fornece a capacidade de "moldagem" (também denominado "conversão de tipo" ou casting), uma operação que, caso seja possível, força a conversão de um objecto de um tipo para outro. Apesar de ser por vezes necessário, o uso de conversões de tipo sacrifica alguma segurança oferecida pelo sistema de tipos.

int

O tipo de dado int (inteiro) serve para armazenar valores numéricos inteiros. Existem vários tipos de inteiros, cada um de um tamanho diferente (dependendo do sistema operacional e/ou arquitetura do processador):

• int, pode possuir 16 bits, 32 bits ou 64 bits
• short int, deve possuir tamanho de no mínimo 16 bits e não pode ser maior que int
• long int, deve possuir tamanho mínimo de 32 bits
• long long int, deve possuir tamanho mínimo de 64 bits

Todos estes tipos de inteiros podem ainda ser declarados precedidos da cláusula unsigned, o que faz com que só suporte números positivos. Isto faz com que, com o mesmo tamanho, uma variável suporte mais números positivos do que um signed (todos os inteiros são signed por omissão).

char

O tipo char ocupa 1 byte, e serve para armazenar caracteres ou inteiros. Isso significa que o programa reserva um espaço de 8 bits na memória RAM ou em registradores do processador para armazenar um valor (char de tamanho maior que 8 bits é permitido pela linguagem, mas os casos são raros). Com vetores do tipo char é possível criar cadeias de caracteres (strings).

float

O tipo de dado float serve para armazenar números de ponto flutuante, ou seja, com casas decimais. O padrão mais utilizado nos últimos 10 anos é o IEEE 754-1985.

double

O tipo de dado double serve para armazenar números de ponto flutuante de dupla precisão, normalmente tem o dobro do tamanho do float e portanto o dobro da capacidade. O padrão mais adotado também é o IEEE 754-1985.

struct

Em C podem ser usadas estruturas (chamados de registos em outras linguagens de programação). As estruturas são grupos de variáveis organizadas arbitráriamente pelo programador. Uma estrutura pode criar um novo tipo de variável caso typedef seja usado em sua declaração.

Exemplo:

#include <stdio.h>   struct pessoa  {    unsigned short int idade;    char nome[51]; /* vetor de 51 chars para o nome */    unsigned long int rg; }; /* estrutura declarada */   int main(void) {    struct pessoa exemplo = {16, "Fulano", 123456789}; /* declaração de uma variável tipo struct pessoa */      printf("Idade: %hu\n", exemplo.idade);    printf("Nome: %s\n", exemplo.nome);    printf("RG: %lu\n", exemplo.rg);      return 0; } 

Esta estrutura é composta por 3 elementos de tipos diferentes. Depois de ser declarada uma variável do tipo struct x, onde x é o nome da estrutura, para se acessar os diversos elementos deve-se fazer x.elemento

[editar] Relações com C++

A linguagem de programação C++ foi originalmente derivada do C para suportar programação orientada a objetos. À medida que as linguagens C e C++ foram evoluindo independentemente, a divisão entre as duas veio a aumentar. O padrão C99 criou um número de características que entram em conflito. Hoje, as principais diferenças entre as duas linguagens são:

• inline - em C++, funções em linha encontram-se no espaço global enquanto que em C encontram-se no espaço local. Por outras palavras, isso significa que, em C++, qualquer definição de qualquer função em linha (sem ser a respeito da sobrecarga de funções de C++) tem de estar em conformidade com a "regra de uma definição" da linguagem C++. Mas em C, a mesma função em linha pode ser definida de maneira diferente em diferentes arquivos (ou ficheiros).
• A palavra-chave bool, igual à usada em C++, em C99 necessita que se inclua o ficheiro-cabeçalho <stdbool.h> (_Bool está sempre disponível). Padrões anteriores de C não definiam um tipo booleano e vários (e incompatíveis) métodos foram usados para simular um tipo booleano.

Algumas características originalmente desenvolvidas em C++ também apareceram em C. Entre elas encontram-se:

• protótipos de função (com declaração de tipos de parâmetros) e remoção do "int" implícito.
• comentários de linha, indicados por //; comentários de linha terminam com um carácter de nova-linha
• a palavra-chave inline
• tipagem mais forte.

[editar] Exemplos

[editar] "Olá, Mundo!"

A seguinte aplicação foi publicada na primeira edição de C de K&R, e tornou-se no programa de introdução padrão da maior parte dos livros sobre C. O programa envia o texto "Olá Mundo!" para a saída padrão, que é normalmente o console, mas que também pode ser um ficheiro (ou arquivo), um outro dispositivo qualquer, ou até mesmo um bit bucket, dependendo de como a saída-padrão é mapeada na altura em que o programa é executado.

int main() {    printf("Olá, Mundo!\n"); } 

Apesar do programa acima correr corretamente, atualmente origina algumas mensagens de aviso quando compilado com C ANSI. Essas mensagens podem ser eliminadas efectuando umas pequenas alterações no programa original:

#include <stdio.h> /* Pacotes com funções de entrada e saída */ #include <math.h> /* Este pacote é desnecessário, mas mostra que podem ser adicionados outros pacotes */   int main(void) {    printf("Olá, Mundo!\n");    return 0; /* Retorna 0, pois main retorna um int */ } /* Nova linha após fechar a chave principal */ 

A primeira linha do programa é uma diretiva de pré-processamento #include, que causa com que o pré-processador substitua aquela linha pela totalidade do conteúdo do arquivo qual diretiva se refere. Neste caso o arquivo padrão stdio.h (que contém protótipos de funções para trabalho com entrada e saída) irá substituir a linha. Os caracteres < e > indicam que o arquivo stdio.h encontra-se no local em que, quando da configuração do compilador, se definiu como padrão para localização dos ficheiros de inclusão (header files, geralmente com a extensão .h).

A linha (não-vazia) seguinte indica que uma função denominada main será definida. A função main tem um significado especial nos programas de C, pois é a função que é inicialmente executada ou em inglês entry point. Os caracteres { e } delimitam a extensão da função. O termo int define a função main como sendo uma função que retorna um número inteiro. O termo void indica que a função não aceita parâmetros. A função main, normalmente aceita parâmetros, que são passado pela linha de comando. Os compiladores e sistemas operacionais atuais reconhecem as seguintes declarações de main:

int main (int argc, char ** argv)  int main (int argc, char * argv[]) 

A linha seguinte "chama", ou executa uma função chamada printf; o arquivo incluído, stdio.h, contém a informação que descreve a forma como a função printf deve ser chamada. Nesta chamada, é passado à função printf um único argumento, a linha de texto constante "Olá Mundo!\n". A função printf retorna um valor, um int, mas como não é usado ela é descartada pelo compilador. O comando return retorna o valor 0 para o sistema, que é interpretado pelo mesmo como que a função main() foi executada e encerrada com sucesso (sem erros). Por fim, o caracter } indica o fim da função main. Note-se que texto rodeado por /* e */ (comentários de texto) é ignorado pelo compilador. Os compiladores que obedecem à norma C99 também aceitam como comentários as linhas de texto que são precedidos por //.

[editar] Soma simples

O seguinte código executa uma soma, de duas variáveis. Primeiro são definidas as variáveis a e b, do tipo inteiro. Em seguida é mostrado na tela, com o comando printf, o texto a + b = , e após o símbolo de igual o resultado da conta, que é 10. Portanto o resultado final seria:

a + b = 10

#include <stdio.h>   int main() {    int a = 3, b = 7;      printf("a + b = %d\n", a+b);      return 0; } 

Alterando esse código, pode-se interagir com o usuário. Dessa forma, o usuário digita dois valores e em seguida é mostrada a soma deles.

#include <stdio.h>   int main() {    int x, y; //define duas variáveis      printf("x = ");     scanf("%d", &x); //scanf atribui o valor digitado a x      printf("y = ");    scanf("%d", &y); //scanf atribui o valor digitado a y      printf("x + y = %d\n", x+y); //printf mostra na tela o resultado.      return 0; } 

A execução desse programa seria a seguinte, se o usuário digitar 5 para x e 6 para y.

x = 5

y = 6

x + y = 11

[editar]

                          Programacao de computadore de linguagem C++

Programacao de linguagem C++

                   Programacao de linguagem c++

#include <cstdlib>
#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

template <class Functor, class T>
inline vector<T> apply( const vector<T>& v, Functor f ) {
  vector<T> resultado;

  for(typename vector<T>::const_iterator i = v.begin();
                                i != v.end(); ++i )
    resultado.push_back( f( *i ) );
   
  return resultado;
}

template <class Functor, class T>
inline void map( vector<T>& v, Functor f ) {
  for(typename vector<T>::iterator i = v.begin();
                                   i != v.end(); ++i )
    f( *i );
}

...
Bla bla, functores pra soma, subtração divisão, atribuição do place holder bla bla....
...

// Eis o Place Holder :

class PlaceHolder {
  public:
    template <class T>
    T operator()( T n ) { return n; }
   
    template <class T>
    Atribuicao< Lambda<T> > operator = ( Lambda<T> valor ) {
        typedef Atribuicao< Lambda<T> > ATRIBUICAO;
       
        return ATRIBUICAO( Lambda<T>( valor ) );
      }
   
    template <class T>
    Atribuicao< Lambda< Constante<T> > > operator = ( T valor ) {
        typedef Atribuicao< Lambda< Constante<T> > > ATRIBUICAO;
       
        return ATRIBUICAO( Lambda< Constante<T> >( valor ) );
      }
} x;

...
Bla bla, functores pra soma, subtração divisão, atribuição do membro atribuiado ao place holder bla bla....
...


#define Lazy( nome ) \
struct F_##nome { \
  template <class T> \
  T operator()( T n ) { return nome(n); }\
}; \
\
template <class T> \
inline Lambda< F_##nome > nome( Lambda<T> ) { \
   return Lambda< F_##nome >( F_##nome() ); \
} \
\
inline Lambda< F_##nome > nome( PlaceHolder ) { \
   return Lambda< F_##nome >( F_##nome() ); \
}

Lazy( sin );
Lazy( cos );

int main(int argc, char *argv[])
{
  vector<double> v;

  v, 0.0, 0.22, 0.3, 0.4, 0.5, M_PI/2;


   // Deveria atribuir dez a cada elemento do array.
  map( v, x = sin(x)*sin(x) + cos(x)*cos(x) );


  cout << v << endl;

  system("PAUSE");
  return 0;
}

O usuário deve ter o Dev-C++, cujo download pode ser feito através do site http://www.bloodshed.net/.
Se você já tem o Dev-C++ instalado, deve baixar a api do MySQL para C++. O site e-help possui a api e um exemplo de aplicação. Entre em www.ehelp.eti.br, na seção de downloads, e baixe o Mysql Pacote Dev-C++ com exemplos e api. Para instalar basta dar dois cliques no arquivo mysql.devpak. Após instalado, já podemos usar o Mysql juntamente com o C++.

A seguir, crie um banco de dados com o nome de myteste, e também uma tabela “cliente” com os campos: id (auto), nome (varchar 50), end (varchar 100). Caso deseje insira outros campos. Vamos iniciar a construção de nossa aplicação.
Abra o Dev-C++ e crie um novo projeto, com o nome que desejar, do tipo Console aplication, do tipo projeto c. Entre no menu projeto &#61664;Opções do Projeto (Alt + P). Será aberto uma janela com vários opções. Escolha a opção parâmetro, e na seção linker digite –lmysql, e em seguida ok.
Agora vamos construir nossa aplicação com acesso ao banco de dados. No código fonte inclua o cabeçalho do Windows e MySQL, conforme abaixo:

#include <windows.h>
#include <mysql.h>

Após, crie as variáveis e efetue a conexão:
MYSQL con;
Essa linha cria uma variável de conexão. O nome “com” pode ser alterado para qualquer outro nome, mas não esqueça de alterar no restante do programa.

mysql_init(&con);
Esse comando inicializa a variável “com”, para ser usada.

Agora faça a conexão, conforme abaixo:

mysql_real_connect(&con, "servidor", "usuário", "senha", "banco de dados", 0, NULL, 0);

Por último executaremos a instrução query com o comando mysql_query:
mysql_query (&con, "instrução sql");

Observe que é muito semelhante às instruções do PHP para acesso a manipulação de banco de dados. Agora vamos criar nossa aplicação com os dados apresentados acima:

//inclui os cabeçalhos
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <mysql.h>

int main(int argc, char *argv[])
{
int resquery; //cria uma variável para manter o resultado da consulta
MYSQL con; // cria a variável de conexão
mysql_init(&con); //inicializa a variável de conexão
mysql_real_connect(&con, "localhost", "", "", "myteste", 0, NULL, 0);
//efetua a conexão, não esqueça de colocar o nome do seu banco de dados com os dados de usuario, senha e servidor.
printf("Conectado com sucesso n");
resquery = mysql_query (&con, "Insert into cliente(id, nome, end) values (Null, 'Fabio', ‘endereço’);");
//insere dados na tabela cliente
printf ("Registro inserido %dn", mysql_affected_rows(&con));
//apresenta o resultado da inserção na tabela e com a função mysql_affected_rows mostra quantas linhas foram inseridas no banco de dados.
mysql_close(&con);
//fecha a conexão
system("PAUSE");
return 0;
}

Para finalizar basta compilar e executar. Observe que os dados foram inseridos com sucesso no banco de dados. Os mesmos comandos podem ser aplicados ao Linux, porém é necessário compilar com a opção –Imysql. O código e as funções são as mesmas. Para mais informações sobre como compilar programas em Linux, leia o artigo “Usando GCC”

Visão geral

C é uma linguagem imperativa e procedural, para implementação de sistemas. Seus pontos de design foram para ele ser compilado, fornecendo acesso de baixo nível à memória e baixos requerimentos do hardware. Também foi desenvolvido para ser uma linguagem de alto nível, para maior reaproveitamento do código. C foi útil para muitas aplicações que foram codificadas originalmente em Assembly.

Essa propriedade não foi acidental; a linguagem C foi criada com o objectivo principal em mente: facilitar a criação de programas extensos com menos erros, recorrendo ao paradigma da programação procedural, mas sobrecarregando menos o autor do compilador, cujo trabalho complica-se ao ter de realizar as características complexas da linguagem. Para este fim, a linguagem C possui as seguintes características:

• Uma linguagem extremamente simples, com funcionalidades não-essenciais, tais como funções matemáticas ou manuseamento de ficheiros (arquivos), fornecida por um conjunto de bibliotecas de rotinas padronizada;
• A focalização no paradigma de programação procedural;
• Um sistema de tipos simples que evita várias operações que não fazem sentido
• Uso de uma linguagem de pré-processamento, o pré-processador de C, para tarefas tais como a definição de macros e a inclusão de múltiplos ficheiros de código fonte;
• Ponteiros dão maior flexibilidade à linguagem;
• Acesso de baixo-nível, através de inclusões de código Assembly no meio do programa C;
• Parâmetros que são sempre passados por valor para as funções e nunca por referência (É possível simular a passagem por referência com o uso de ponteiros);
• Definição do alcance lexical de variáveis;
• Estruturas de variáveis, (structs), que permitem que dados relacionados sejam combinados e manipulados como um todo.

Algumas características úteis, que faltam em C, podem ser encontradas em outras linguagens, que incluem:

• Segurança de tipo;
• Coletor de lixo (mais comum em linguagens interpretadas);
• Vetores que crescem automaticamete;
• Classes ou objetos com comportamento (ver Orientação a objetos);
• Closures;
• funções aninhadas;
• Programação genérica;
• Sobrecarga de operadores;
• Meta-programação;
• Apoio nativo de multithreading e comunicação por rede.

Apesar da lista de características úteis que C possui não ser longa, isso não tem sido um impedimento à sua aceitação, pois isso permite que novos compiladores de C sejam escritos rapidamente para novas plataformas, e também permite que o programador permaneça sempre em controle do que o programa está a fazer. Isto é o que por várias vezes permite o código de C correr de uma forma mais eficiente que muitas outras linguagens. Tipicamente, só código de Assembly "afinado à mão" é que corre mais rapidamente, pois possui um controle completo da máquina, mas avanços na área de compiladores juntamente com uma nova complexidade nos processadores modernos permitiram que a diferença tenha sido rapidamente eliminada. Uma consequência da aceitação geral da linguagem C é que frequentemente os compiladores, bibliotecas e até intérpretes de outras linguagens de nível maior sejam eles próprios implementados em C.

C tem como ponto forte, a sua eficiência, e é a linguagem de programação preferida para o desenvolvimento de sistemas e softwares de base, apesar de também ser usada para desenvolver programas de computador. É também muito usada no ensino de ciência da computação, mesmo não tendo sido projetada para estudantes e apresentando algumas dificuldades no seu uso. Outra característica importante de C, é sua proximidade do código de máquina, que permite que um projetista seja capaz de fazer algumas previsões de como o software irá se comportar, ao ser executado.

C tem como ponto fraco, a falta de proteção que dá ao programador. Praticamente tudo que se expressa em um programa em C, pode ser executado, como por exemplo, pedir o vigésimo membro de um vetor com apenas dez membros. Os resultados são muitas vezes totalmente inesperados, e os erros, difíceis de encontrar.

Apesar de bastante funcional e eficiente, a linguagem C não é a linguagem preferida de desenvolvedores de jogos. Por causa dessa falta de segurança e de sua menor capacidade de criação de softwares complexos, costuma-se preferir uma linguagem que forneça resultados mais satisfatórios, como por exemplo, C++. ^{[carece de fontes?]}

[editar] Tipos de dados

C tem um sistema de tipos semelhante ao de alguns descendentes da linguagem ALGOL, tais como Pascal. Possui tipos para números inteiros de vários tamanhos com e sem sinal, números de ponto flutuante, caracteres e estruturas (structs). C usa extensivamente ponteiros, um tipo muito simples de referência que guarda o endereço de memória da variável. O ponteiro pode ser desreferenciado, uma operação que busca o objecto que se encontra na morada da memória que o ponteiro possui, morada essa que pode ser manipulada através de aritmética de ponteiros. Durante o tempo de execução, o ponteiro é simplesmente uma morada de máquina tais como aquelas manipuladas em Assembly, mas em tempo de compilação possui um tipo complexo que indica o tipo do objecto para onde ele aponta, permitindo que se verifique o tipo de expressões, incluindo ponteiros. Os ponteiros são usados extensivamente em C. O tipo linha de texto de C é simplesmente um ponteiro para um vetor de caracteres e alocação dinâmica de memória, descrita abaixo, é efectuada através de ponteiros.

Os ponteiros em C possuem um valor reservado especial, NULL, que indica que não estão a apontar para uma morada. O uso desse valor como morada é muito útil na construção de várias estruturas de dados, mas causa comportamento não-definido (possivelmente uma falha de sistema) ao ser desreferenciado. Um ponteiro que possui o valor NULL é chamado ponteiro nulo. Os ponteiros são declarados (e desreferenciados) com um * (asterisco), portanto o tipo int* denota um ponteiro para número(s) inteiro(s). A linguagem C também fornece um tipo especial de ponteiros, o void*, que se traduz num ponteiro que aponta para um objecto de tipo desconhecido.

A linguagem C também tem apoio a nível de linguagem para vetores estáticas (de dimensão fixa) de tipos. As disposições de tipos podem parecer ter mais que uma dimensão apesar de serem tecnicamente disposições de disposições de tipos. Em memória, tais estruturas são posicionadas com as linhas uma depois da outra (a alternativa seria armazenar os dados em colunas, usado em outras linguagens). O acesso a disposições de tipos é feito através de ponteiros e aritmética de ponteiros; o nome da disposição é tratado como se fosse um ponteiro que aponta para o início da disposição. Em certas aplicações não é razoável usarem-se disposições de tipos de dimensão fixa e por isso a alocação dinâmica de memória pode ser usada para criar disposições de tipos de dimensão variável.

Como a linguagem C é regularmente usada em programação de baixo-nível de sistemas, há casos em que é necessário tratar um número inteiro como sendo um ponteiro, um número de ponto flutuante como sendo um número inteiro ou um tipo de ponteiro como sendo outro. Para estes casos, a linguagem C fornece a capacidade de "moldagem" (também denominado "conversão de tipo" ou casting), uma operação que, caso seja possível, força a conversão de um objecto de um tipo para outro. Apesar de ser por vezes necessário, o uso de conversões de tipo sacrifica alguma segurança oferecida pelo sistema de tipos.

int

O tipo de dado int (inteiro) serve para armazenar valores numéricos inteiros. Existem vários tipos de inteiros, cada um de um tamanho diferente (dependendo do sistema operacional e/ou arquitetura do processador):

• int, pode possuir 16 bits, 32 bits ou 64 bits
• short int, deve possuir tamanho de no mínimo 16 bits e não pode ser maior que int
• long int, deve possuir tamanho mínimo de 32 bits
• long long int, deve possuir tamanho mínimo de 64 bits

Todos estes tipos de inteiros podem ainda ser declarados precedidos da cláusula unsigned, o que faz com que só suporte números positivos. Isto faz com que, com o mesmo tamanho, uma variável suporte mais números positivos do que um signed (todos os inteiros são signed por omissão).

char

O tipo char ocupa 1 byte, e serve para armazenar caracteres ou inteiros. Isso significa que o programa reserva um espaço de 8 bits na memória RAM ou em registradores do processador para armazenar um valor (char de tamanho maior que 8 bits é permitido pela linguagem, mas os casos são raros). Com vetores do tipo char é possível criar cadeias de caracteres (strings).

float

O tipo de dado float serve para armazenar números de ponto flutuante, ou seja, com casas decimais. O padrão mais utilizado nos últimos 10 anos é o IEEE 754-1985.

double

O tipo de dado double serve para armazenar números de ponto flutuante de dupla precisão, normalmente tem o dobro do tamanho do float e portanto o dobro da capacidade. O padrão mais adotado também é o IEEE 754-1985.

struct

Em C podem ser usadas estruturas (chamados de registos em outras linguagens de programação). As estruturas são grupos de variáveis organizadas arbitráriamente pelo programador. Uma estrutura pode criar um novo tipo de variável caso typedef seja usado em sua declaração.

Exemplo:

#include <stdio.h>
 
struct pessoa 
{
   unsigned short int idade;
   char nome[51]; /* vetor de 51 chars para o nome */
   unsigned long int rg;
}; /* estrutura declarada */
 
int main(void)
{
   struct pessoa exemplo = {16, "Fulano", 123456789}; /* declaração de uma variável tipo struct pessoa */
 
   printf("Idade: %hu\n", exemplo.idade);
   printf("Nome: %s\n", exemplo.nome);
   printf("RG: %lu\n", exemplo.rg);
 
   return 0;
}

Esta estrutura é composta por 3 elementos de tipos diferentes. Depois de ser declarada uma variável do tipo struct x, onde x é o nome da estrutura, para se acessar os diversos elementos deve-se fazer x.elemento

[editar] Relações com C++

A linguagem de programação C++ foi originalmente derivada do C para suportar programação orientada a objetos. À medida que as linguagens C e C++ foram evoluindo independentemente, a divisão entre as duas veio a aumentar. O padrão C99 criou um número de características que entram em conflito. Hoje, as principais diferenças entre as duas linguagens são:

• inline - em C++, funções em linha encontram-se no espaço global enquanto que em C encontram-se no espaço local. Por outras palavras, isso significa que, em C++, qualquer definição de qualquer função em linha (sem ser a respeito da sobrecarga de funções de C++) tem de estar em conformidade com a "regra de uma definição" da linguagem C++. Mas em C, a mesma função em linha pode ser definida de maneira diferente em diferentes arquivos (ou ficheiros).
• A palavra-chave bool, igual à usada em C++, em C99 necessita que se inclua o ficheiro-cabeçalho <stdbool.h> (_Bool está sempre disponível). Padrões anteriores de C não definiam um tipo booleano e vários (e incompatíveis) métodos foram usados para simular um tipo booleano.

Algumas características originalmente desenvolvidas em C++ também apareceram em C. Entre elas encontram-se:

• protótipos de função (com declaração de tipos de parâmetros) e remoção do "int" implícito.
• comentários de linha, indicados por //; comentários de linha terminam com um carácter de nova-linha
• a palavra-chave inline
• tipagem mais forte.

[editar] Exemplos

[editar] "Olá, Mundo!"

A seguinte aplicação foi publicada na primeira edição de C de K&R, e tornou-se no programa de introdução padrão da maior parte dos livros sobre C. O programa envia o texto "Olá Mundo!" para a saída padrão, que é normalmente o console, mas que também pode ser um ficheiro (ou arquivo), um outro dispositivo qualquer, ou até mesmo um bit bucket, dependendo de como a saída-padrão é mapeada na altura em que o programa é executado.

int main()
{
   printf("Olá, Mundo!\n");
}

Apesar do programa acima correr corretamente, atualmente origina algumas mensagens de aviso quando compilado com C ANSI. Essas mensagens podem ser eliminadas efectuando umas pequenas alterações no programa original:

#include <stdio.h> /* Pacotes com funções de entrada e saída */
#include <math.h> /* Este pacote é desnecessário, mas mostra que podem ser adicionados outros pacotes */
 
int main(void)
{
   printf("Olá, Mundo!\n");
   return 0; /* Retorna 0, pois main retorna um int */
} /* Nova linha após fechar a chave principal */

A primeira linha do programa é uma diretiva de pré-processamento #include, que causa com que o pré-processador substitua aquela linha pela totalidade do conteúdo do arquivo qual diretiva se refere. Neste caso o arquivo padrão stdio.h (que contém protótipos de funções para trabalho com entrada e saída) irá substituir a linha. Os caracteres < e > indicam que o arquivo stdio.h encontra-se no local em que, quando da configuração do compilador, se definiu como padrão para localização dos ficheiros de inclusão (header files, geralmente com a extensão .h).

A linha (não-vazia) seguinte indica que uma função denominada main será definida. A função main tem um significado especial nos programas de C, pois é a função que é inicialmente executada ou em inglês entry point. Os caracteres { e } delimitam a extensão da função. O termo int define a função main como sendo uma função que retorna um número inteiro. O termo void indica que a função não aceita parâmetros. A função main, normalmente aceita parâmetros, que são passado pela linha de comando. Os compiladores e sistemas operacionais atuais reconhecem as seguintes declarações de main:

int main (int argc, char ** argv) 
int main (int argc, char * argv[])

A linha seguinte "chama", ou executa uma função chamada printf; o arquivo incluído, stdio.h, contém a informação que descreve a forma como a função printf deve ser chamada. Nesta chamada, é passado à função printf um único argumento, a linha de texto constante "Olá Mundo!\n". A função printf retorna um valor, um int, mas como não é usado ela é descartada pelo compilador. O comando return retorna o valor 0 para o sistema, que é interpretado pelo mesmo como que a função main() foi executada e encerrada com sucesso (sem erros). Por fim, o caracter } indica o fim da função main. Note-se que texto rodeado por /* e */ (comentários de texto) é ignorado pelo compilador. Os compiladores que obedecem à norma C99 também aceitam como comentários as linhas de texto que são precedidos por //.

[editar] Soma simples

O seguinte código executa uma soma, de duas variáveis. Primeiro são definidas as variáveis a e b, do tipo inteiro. Em seguida é mostrado na tela, com o comando printf, o texto a + b = , e após o símbolo de igual o resultado da conta, que é 10. Portanto o resultado final seria:

a + b = 10

#include <stdio.h>
 
int main()
{
   int a = 3, b = 7;
 
   printf("a + b = %d\n", a+b);
 
   return 0;
}

Alterando esse código, pode-se interagir com o usuário. Dessa forma, o usuário digita dois valores e em seguida é mostrada a soma deles.

#include <stdio.h>
 
int main()
{
   int x, y; //define duas variáveis
 
   printf("x = "); 
   scanf("%d", &x); //scanf atribui o valor digitado a x
 
   printf("y = ");
   scanf("%d", &y); //scanf atribui o valor digitado a y
 
   printf("x + y = %d\n", x+y); //printf mostra na tela o resultado.
 
   return 0;
}

A execução desse programa seria a seguinte, se o usuário digitar 5 para x e 6 para y.

x = 5

y = 6

x + y = 11

[editar] Ferramentas de programação

• Bloodshed Dev-C++
• Code::Blocks
• GNU Compiler Collection
• Make

Referências

[editar] Ver também

Outros projetos Wikimedia também contêm material sobre este tema:
	Livros e manuais no Wikilivros

• Linguagem compilada
• Linguagem de programação
• Linguagem de programação de alto nível
• Lista de linguagens de programação
• Unix
• Compiladores

Programaçao de linguagem c

Notar que o caracter lido é armazenado na variável caracter, do tipo int, e que a função vai posicionar -se no ficheiro na próxima posição, ou seja, no caracter seguinte. Não há necessidade de invocar funções de posicionamento para esse efeito.

Programa exemplo :

O programa seguinte lê o ficheiro “texto.txt” e conta o número de caracteres.

Para focar apenas o essencial não vou incluir qualquer tipo de verificação (falha de segmentação) e parto do princípio que existe o ficheiro “texto.txt” na directoria onde vamos testar o programa. Será conveniente utilizar um editor de texto para criar o ficheiro de texto, que pode ser algo do tipo:

gora vamos ao código.

Observações:

O ficheiro é aberto no modo de leitura, e parte-se do princípio que este existe.
Cada caracter lido não é armazenado numa variável, sendo utilizado apenas na condição do ciclo “while”.
Foi utilizado um ciclo “while” para percorrer o ficheiro byte-a-byte, utilizando a constante simbólica EOF para controlar o fim do ficheiro (EOF=End Of File, cujo valor é -1).
Conte atentamente os caracteres do ficheiro de texto, pois até as mudanças de linha são representadas por um caracter “invisível”.
Caso pretendessemos realizar alguma operação com os caracteres lidos, como por exemplo mostrar o conteúdo do ficheiro antes de apresentar a contagem dos caracteres, facilmente poderíamos alterar o código para a versão apresentada a seguir.

#include <stdio.h>
int main(){
    FILE *fp;           /* apontador para o ficheiro */
    int contador = 0;   /* para contar os caracteres */
    int caracter;       /* inteiro para armazenar cada caracter lido */
 
    /* Abrir o ficheiro */
    fp = fopen("texto.txt", "r");
 
    /* Contar os caracteres do ficheiro */
    while ((caracter=fgetc(fp)) != EOF){
        putchar(caracter);
        contador++;
    }
    printf("\nNúmero total de caracteres = %d\n",contador);
 
    /* Fechar o ficheiro */
    fclose(fp);
 
    /* Terminar o programa */
    return 0;
}

Observações:

A variável “caracter” foi declarada com o tipo “int”. Isto deve-se ao facto de haver necessidade de comparar os caracteres lidos com a constante EOF, que como já referi tem o valor -1, que não é suportado pelo tipo “char”.
fputc – Escrever um caracter num ficheiro

Protótipo: int fputc(int caracter, FILE *nomeficheiro)

Exemplo de escrita de um caracter:

fputc('x', nome);

O caracter ‘x’ é escrito no ficheiro apontado por “nome”.

Programa exemplo :

O programa seguinte armazena uma cadeia de caracteres num ficheiro “texto.txt”. Caso o ficheiro já exista este será substituído.

#include <stdio.h>
int main(){
    FILE *fp;                                /* apontador para o ficheiro */
    char texto[]="que lindo dia\nai ai";    /* texto a enviar para o ficheiro */
    int i=0;                                /* para ler a string caracter a caracter */
 
    /* Abrir o ficheiro */
    fp = fopen("texto.txt", "w");
 
    /* Contar os caracteres do ficheiro */
    while (texto[i]!='\ 0')
        fputc(texto[i++], fp);
 
    /* Fechar o ficheiro */
    fclose(fp);
 
    /*Terminar o programa */
    return 0;
}

Observações:

Não tem nada a ver com linguagem C, mas tive que utilizar um espaço entre os caracteres \ e 0. Caso queiram compilar o programa não se esqueçam de remover este espaço. O plugin que estou a utilizar no WordPress não está a 100%. Corrijo isto assim que me for possível
O ficheiro é aberto no modo de escrita “w”, pelo que caso não exista será criado, e caso contrário será substituído ( ver modos de abertura ).
A string é percorrida caracter-a-caracter até ser detectado o seu terminador, ou seja, o caracter ”.
A instrução fputc(texto[i++], fp); primeiro escreve o caracter no ficheiro, e de seguida incrementa o valor de i.

Font: Graciano Torrão