Criar um Blog
Gerenciar um Blog
Visitar Próximo Blog
Denuncie

$ title
Programadore computadores C++

$ description


$ menu
[home] [profile] [archives] [friends]

$ Introduçao á Programaçao c (7/9/2010)

 

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 }

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:

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

Tipo   Tamanho   Valores Válidos
char 1 byte letras e símbolos:   'a',  'b', 'H', '^', '*','1','0'
int 2 bytes de -32767 até 32767 (apenas números inteiros)
float 4 bytes de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de precisão
double 8 bytess de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

 

Declaração de Variáveis

 // 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:

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

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);
Produto Preço Unitário Quantidade Preço Total
Banana R$   2.50

2

R$     5.00
Uva R$   6.50

6

R$    39.00
Pessego R$  10.22

10

R$   102.20
    Sub-Total R$   146.20
  Imposto (5%) R$     7.31
Total R$   153.51
[1 comentários] [link]

$ Olho de programaçao c (7/9/2010)

 

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.
 

Up

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.
 

Up

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:

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.
 
Up


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.

Modelo de Compilação

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:

Por exemplo:

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).
 
Up


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:

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

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

Up

Marcos históricos

 

Up

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.
 

Up


 
 

[0 comentários] [link]

$ Programaçao de computadores de linguagem c (7/9/2010)

jogosdia.webnode.com.br

[0 comentários] [link]

$ deselvomento de lingaugem c (7/9/2010)

http://www.google.com.br/imgres?imgurl=http://cursos.cdtc.org.br/file.php/1/imagens/logo_C.jpg&imgrefurl=http://cursos.cdtc.org.br/course/info.php%3Fid%3D807&usg=__JvO2IaiXTtAHodcgVhnydQ3QODg=&h=300&w=420&sz=37&hl=pt-BR&start=0&zoom=1&tbnid=r5uK1zsZGkwFGM:&tbnh=139&tbnw=195&prev=/images%3Fq%3Dimagens%2Bde%2Bprogramacao%2Bde%2Blinguagem%2Bc%26um%3D1%26hl%3Dpt-BR%26sa%3DN%26biw%3D1920%26bih%3D1047%26tbs%3Disch:1&um=1&itbs=1&iact=hc&vpx=133&vpy=84&dur=1743&hovh=190&hovw=266&tx=150&ty=114&ei=e6uGTLKlMMKB8gbSo91N&oei=e6uGTLKlMMKB8gbSo91N&esq=1&page=1&ndsp=31&ved=1t:429,r:0,s:0

[0 comentários] [link]

$ Protótipo de funçao c (7/9/2010)

#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;

[0 comentários] [link]

$ deselvomento Programacao de computadores linguagem c (7/9/2010)

            Programacao de computadores de linguagem c

 

Programacao de computadoresprogramacao

 

 

#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):

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:

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

[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]

[0 comentários] [link]

$ Linguagem c (7/9/2010)

                          Programacao de computadore de linguagem C++

 

Programacao de linguagem C++

Programacao de linguagem c

[0 comentários] [link]

$ Programadore computadores C++ (7/9/2010)

                   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:

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

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):

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:

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

[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

Referências

  1. History of the C Programming Language (em inglês). Página visitada em 23 de maio de 2010.
  2. Programming Language Popularity (em inglês). Página visitada em 23 de maio de 2010.
  3. TIOBE Programming Community Index (em inglês). Página visitada em 23 de maio de 2010.
  4. C – The Influence Factor of Many Popular Programming Languages (em inglês). Página visitada em 23 de maio de 2010.
  5. Microsoft dá mais ênfase ao C++ (em inglês). Página visitada em 23 de maio de 2010.
  6. Grupo de trabalho do ISO C (em inglês). Página visitada em 23 de maio de 2010.

[editar] Ver também

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


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.

Citação:
#include <stdio.h>
int main(){
FILE *fp; /* apontador para o ficheiro */
int contador = 0; /* variável para contar os caracteres */

/* Abrir o ficheiro */
07
fp = fopen("texto.txt", "r");

/* Contar os caracteres do ficheiro */
while (fgetc(fp) != EOF)
contador++;
printf("Número total de caracteres = %d\n",contador);

/* Fechar o ficheiro */
fclose(fp);

/* Terminar o programa */
return 0;
}

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.

Código:
#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:

Código:
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.

Código:
#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


[0 comentários] [link]