Introdução à Linguagem C

Thiago Victor Oliveira Faria

Professor: Claudio Lemos de Souza
Universidade Federal de Catalão
Setembro de 2024

1
Contents
1 Linguagem C 3
1.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Evolução da Linguagem C . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Aplicações Práticas . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.1 Exemplo de Código: Sistema Embarcado . . . . . . . . . 5
1.4 Caracterı́sticas da Linguagem C . . . . . . . . . . . . . . . . . . . 6
1.5 Estruturas Condicionais . . . . . . . . . . . . . . . . . . . . . . . 7
1.6 Laços de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.7 Funções em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.7.1 Definição de Funções . . . . . . . . . . . . . . . . . . . . . 8
1.8 Chamada de Funções . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.9 Tipos de Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2 Método de Eliminação de Gauss 9

3 Polinômio interpolador 11

2
1 Linguagem C
A apresentação da linguagem C introduz sua importância e caracterı́sticas. Cri-
ada por Dennis Ritchie nos anos 1970, C é eficiente, portátil e oferece controle
sobre o hardware. Usada em sistemas operacionais, compiladores e aplicações
embarcadas, sua sintaxe simples a torna acessı́vel para iniciantes e robusta para
programadores experientes. C também é a base de várias linguagens modernas,
sendo fundamental na educação em ciência da computação e no desenvolvimento
de software.

1.1 Introdução
A linguagem C se destaca como uma das linguagens de programação mais in-
fluentes e amplamente adotadas na história do desenvolvimento de software.
Desenvolvida na década de 1970 por Dennis Ritchie nos laboratórios Bell, a C
não é apenas uma linguagem de programação, mas um verdadeiro marco na
evolução da computação. Sua eficiência e flexibilidade, aliadas à capacidade de
manipulação de baixo nı́vel, tornam-na uma escolha preferencial para o desen-
volvimento de sistemas operacionais, compiladores e aplicações que exigem alta
performance.
O design da C permite que programadores interajam diretamente com o
hardware, proporcionando um controle fino sobre recursos do sistema, o que
é essencial em ambientes onde a eficiência é crı́tica. Além disso, sua sintaxe
simples e poderosa facilitou a aprendizagem e o domı́nio, tornando-se uma porta
de entrada para muitas outras linguagens que se seguiram.
Por sua relevância, a linguagem C não apenas influenciou a criação de out-
ras linguagens, como C++, C#, e Java, mas também continua a ser uma base
sólida para cursos de ciência da computação em todo o mundo. Neste trabalho,
exploraremos os princı́pios fundamentais da linguagem C, suas caracterı́sticas
distintivas e sua aplicação prática, oferecendo uma visão abrangente para aque-
les que desejam mergulhar neste campo fascinante.

1.2 Evolução da Linguagem C

Desde sua criação na década de 1970, a linguagem C passou por várias versões,
cada uma trazendo inovações que ampliaram suas capacidades e melhoraram
sua usabilidade. A seguir, exploramos as principais iterações da linguagem e
suas contribuições para o mundo da programação:
• C89/C90: O primeiro padrão formal da linguagem, adotado pelo ANSI
(American National Standards Institute) em 1989, estabeleceu as bases
para a sintaxe e as bibliotecas da linguagem. O padrão C89 garantiu
portabilidade e consistência entre compiladores, permitindo que desen-
volvedores criassem aplicações que pudessem ser facilmente transferidas
entre diferentes sistemas. Esta versão também introduziu o conceito de
protótipos de função, que melhorou a verificação de tipo durante a com-
pilação.

3
 int soma ( int a , int b ) ;

• C99: Lançado em 1999, essa versão introduziu novas funcionalidades sig-

nificativas, como:
– Tipos de dados booleanos: O tipo bool foi adicionado, permitindo
que os programadores trabalhassem de maneira mais intuitiva com
valores booleanos.
– Comentários em linha: A possibilidade de usar // para comentários
facilitou a documentação do código.
– Declarações de variáveis em qualquer ponto do bloco de código: Isso
trouxe maior flexibilidade na definição de variáveis.
– Funções variádicas: Permitiram a criação de funções que aceitam um
número variável de argumentos.

#i n c l u d e <s t d b o o l . h>
bool verdadeiro = true ;

• C11: Publicado em 2011, o C11 focou em melhorias para programação

concorrente e segurança. As adições mais notáveis incluem:
– Suporte para multithreading: A biblioteca threads.h introduziu no-
vas funções para facilitar a criação e o gerenciamento de threads,
permitindo que os programadores aproveitassem melhor os proces-
sadores multicore.
– Melhorias na segurança: Novas funções para tratamento de strings
e operações de memória foram introduzidas para reduzir o risco de
vulnerabilidades comuns, como buffer overflow.

#i n c l u d e <t h r e a d s . h>
void t h r e a d f u n c ( ) {
// C d i g o da t h r e a d
}

• C18: Lançada em 2018, esta versão é uma atualização menor que se con-
centrou em correções e melhorias ao padrão anterior. Embora não tenha
introduzido novos recursos significativos, C18 consolidou e estabilizou as
funcionalidades do C11, garantindo que a linguagem continuasse a ser
confiável e relevante no desenvolvimento de software contemporâneo.

1.3 Aplicações Práticas

A linguagem C continua a ser amplamente utilizada em diversas áreas, devido
à sua eficiência, flexibilidade e controle sobre o hardware. A seguir, destacamos
algumas das principais aplicações:

4
 • Desenvolvimento de Sistemas Operacionais: C é a linguagem prin-
cipal usada na implementação de sistemas operacionais. Por exemplo, os
núcleos de sistemas operacionais populares, como Linux, Windows e ma-
cOS, são escritos em grande parte em C. Isso se deve à capacidade da
linguagem de manipular diretamente a memória e interagir com o hard-
ware.
• Desenvolvimento de Compiladores: Muitos compiladores modernos,
como o GCC (GNU Compiler Collection), são desenvolvidos em C. A es-
colha por C se deve à sua eficiência em gerar código de máquina otimizado
e seu suporte para operações de baixo nı́vel, que são essenciais para a con-
strução de compiladores.

• Programação de Embarcados: A linguagem C é amplamente utilizada

na programação de sistemas embarcados, como microcontroladores e dis-
positivos IoT (Internet das Coisas). Isso ocorre porque C permite acesso
direto ao hardware, tornando-o ideal para aplicações onde o desempenho
e a eficiência energética são cruciais.

À medida que a tecnologia avança, C continua a ser uma escolha robusta

para desenvolvedores que buscam desempenho e controle sobre os recursos do
sistema. O futuro da linguagem C é promissor, especialmente com o crescimento
da programação em tempo real e aplicações de alto desempenho.

1.3.1 Exemplo de Código: Sistema Embarcado

A seguir, apresentamos um exemplo simples de um programa em C que pode
ser usado em um sistema embarcado. Este código simples pisca um LED em
um microcontrolador.
#include <avr / i o . h> // B i b l i o t e c a para AVR
#include < u t i l / d e l a y . h> // B i b l i o t e c a para d e l a y

#define LED PIN PB0 // D e f i n e o p i n o do LED

int main ( void ) {

// C o n f i g u r a o p i n o do LED como s a d a
DDRB |= ( 1 << LED PIN ) ;

while ( 1 ) {
// Liga o LED
PORTB |= ( 1 << LED PIN ) ;
d e l a y m s ( 5 0 0 ) ; // Espera 500 ms

// D e s l i g a o LED
PORTB &= ˜ ( 1 << LED PIN ) ;
d e l a y m s ( 5 0 0 ) ; // Espera 500 ms

5
 }
return 0 ;
}
Neste exemplo, utilizamos a biblioteca AVR para configurar um microcon-
trolador e piscar um LED conectado ao pino definido. O programa alterna entre
ligar e desligar o LED a cada 500 milissegundos, mostrando como C é usado
para interagir diretamente com hardware em sistemas embarcados.
Esse exemplo ilustra a simplicidade e a eficiência do código C em aplicações
práticas, além de mostrar como ele é fundamental em ambientes onde o controle
de hardware é essencial.

1.4 Caracterı́sticas da Linguagem C

A linguagem C possui diversas caracterı́sticas que a tornam única e amplamente
utilizada, tanto em ambientes acadêmicos quanto em aplicações industriais. A
seguir, destacamos algumas das principais caracterı́sticas que definem a lin-
guagem:

• Simplicidade: A sintaxe da linguagem C é clara e concisa, facilitando

a leitura e a escrita do código. Esta simplicidade permite que novos pro-
gramadores aprendam rapidamente os conceitos básicos, enquanto desen-
volvedores experientes podem escrever códigos complexos de forma efi-
ciente. A estrutura modular da C também permite a decomposição de
problemas em funções menores e gerenciáveis.
• Portabilidade: Um dos principais atrativos da linguagem C é sua porta-
bilidade. Os programas escritos em C podem ser facilmente compila-
dos e executados em diferentes plataformas, desde microcontroladores até
grandes sistemas operacionais, sem necessidade de reescrita significativa.
Essa caracterı́stica é fundamental em ambientes de desenvolvimento, onde
a compatibilidade entre sistemas é crucial.
• Eficiência: C proporciona um controle preciso sobre os recursos do sis-
tema, como memória e processamento. A linguagem permite que os pro-
gramadores acessem diretamente a memória através de ponteiros, possi-

6
 bilitando operações de baixo nı́vel que são essenciais em aplicações que
requerem alto desempenho, como jogos, sistemas operacionais e softwares
embarcados. Esta eficiência se traduz em programas que não apenas exe-
cutam rapidamente, mas também consomem menos recursos.
• Tipagem Estática: A tipagem estática na C significa que todas as
variáveis devem ser declaradas com um tipo especı́fico antes de serem
utilizadas. Isso ajuda a detectar erros de tipo em tempo de compilação,
aumentando a robustez do código. A verificação de tipos em tempo de
compilação também contribui para a performance, já que o compilador
pode otimizar o código gerado.

• Extensibilidade: C permite a criação de bibliotecas e funções, possibili-

tando a reutilização de código. A linguagem também é a base de muitas
outras linguagens de programação, o que significa que seus conceitos po-
dem ser aplicados em diversos contextos. Essa extensibilidade facilita a
adaptação e evolução de projetos de software ao longo do tempo.

Essas caracterı́sticas tornam a linguagem C uma escolha robusta e versátil

para uma ampla gama de aplicações, desde o desenvolvimento de sistemas
operacionais até a programação de dispositivos embarcados, reafirmando sua
relevância no cenário atual da programação.

1.5 Estruturas Condicionais

• if e else

• switch

1.6 Laços de Repetição

• for

• while
• do-while

1.7 Funções em C
As funções são blocos de código reutilizáveis que realizam uma tarefa especı́fica.
Elas permitem que os programadores organizem seu código de forma modular,
facilitando a leitura, a manutenção e a reutilização. Em C, uma função é definida
com um tipo de retorno, um nome, uma lista de parâmetros (opcional) e um
corpo que contém o código a ser executado.

7
1.7.1 Definição de Funções
A sintaxe básica para definir uma função em C é a seguinte:
tipo_retorno nome_da_funç~
ao(tipo parametro1, tipo parametro2, ...) {
// corpo da funç~
ao
}
Exemplo de Função Simples
Abaixo está um exemplo de uma função simples que soma dois números
inteiros:
int soma ( int a , int b ) {
return a + b ;
}
Nesta função, soma recebe dois parâmetros do tipo int e retorna a soma
deles.

1.8 Chamada de Funções

Para usar uma função definida, é necessário chamá-la em algum lugar do código.
Veja um exemplo de como a função soma pode ser chamada:
#include <s t d i o . h>

int soma ( int a , int b ) {

return a + b ;
}

int main ( ) {
int r e s u l t a d o = soma ( 5 , 1 0 ) ; // Chamada da f u n o soma
p r i n t f ( ”A soma : %d\n” , r e s u l t a d o ) ;
return 0 ;
}
Neste exemplo, a função soma é chamada a partir da função main, e o resul-
tado é impresso na tela.

1.9 Tipos de Funções

As funções em C podem ser classificadas em diferentes tipos, dependendo do
seu uso e comportamento:
• Funções Sem Retorno: Também conhecidas como funções void, essas
funções não retornam um valor. Elas podem ser usadas para realizar
tarefas, como imprimir informações ou modificar variáveis globais.
• Funções com Retorno: Essas funções retornam um valor após sua ex-
ecução. O tipo do valor retornado deve ser especificado na definição da
função.

8
 • Funções Recursivas: Funções que se chamam a si mesmas durante a
execução. Elas são frequentemente usadas para resolver problemas que
podem ser divididos em subproblemas menores, como calcular o fatorial
de um número.

Exemplo de Função Recursiva

Aqui está um exemplo de uma função recursiva que calcula o fatorial de um
número:
int f a t o r i a l ( int n ) {
i f ( n <= 1 ) return 1 ; // C o n d i o de parada
return n ∗ f a t o r i a l ( n − 1 ) ; // Chamada r e c u r s i v a
}
Neste caso, a função fatorial chama a si mesma até que a condição de
parada (quando n é menor ou igual a 1) seja alcançada.

2 Método de Eliminação de Gauss

#i n c l u d e <s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e <math . h>

v o i d EGauss ( d o u b l e ∗∗ A, d o u b l e ∗ b , i n t n , i n t k , d o u b l e ∗∗ x ) {
d o u b l e ∗∗ Ax = ( d o u b l e ∗ ∗ ) m a l l o c ( n ∗ s i z e o f ( d o u b l e ∗ ) ) ;
f o r ( i n t i = 0 ; i < n ; i ++) {
Ax [ i ] = ( d o u b l e ∗ ) m a l l o c ( ( n + k ) ∗ s i z e o f ( d o u b l e ) ) ;
f o r ( i n t j = 0 ; j < n ; j ++) {
Ax [ i ] [ j ] = A[ i ] [ j ] ;
}
f o r ( i n t j = 0 ; j < k ; j ++) {
Ax [ i ] [ n + j ] = b [ j ∗ n + i ] ;
}
}

// Fase da e l i m i n a o
f o r ( i n t c o l = 0 ; c o l < n − 1 ; c o l ++) {
f o r ( i n t row = c o l + 1 ; row < n ; row++) {
i f ( f a b s (Ax [ c o l ] [ c o l ] ) < 1 e −16) {
p r i n t f (”??? P i v Numericamente Nulo \n ” ) ;
f r e e (Ax ) ;
return ;
}
d o u b l e m = Ax [ row ] [ c o l ] / Ax [ c o l ] [ c o l ] ;
f o r ( i n t j = c o l + 1 ; j < n + k ; j ++) {
Ax [ row ] [ j ] −= m ∗ Ax [ c o l ] [ j ] ;

9
 }
}
}

// Fase da Retro s o l u o
f o r ( i n t m = 0 ; m < k ; m++) {
i f ( f a b s (Ax [ n − 1 ] [ n ] ) < 1 e −16) {
p r i n t f (”??? P i v Numericamente Nulo \n ” ) ;
f r e e (Ax ) ;
return ;
}
x [ n − 1 ] [m] = Ax [ n − 1 ] [ n + m] / Ax [ n − 1 ] [ n ] ;
}

f o r ( i n t c o l = n − 2 ; c o l >= 0 ; c o l −−) {
f o r ( i n t m = 0 ; m < k ; m++) {
d o u b l e som = 0 ;
f o r ( i n t j = c o l + 1 ; j < n ; j ++) {
som += Ax [ c o l ] [ j ] ∗ x [ j ] [m] ;
}
x [ c o l ] [m] = (Ax [ c o l ] [ n + m] − som ) / Ax [ c o l ] [ c o l ] ;
}
}

f o r ( i n t i = 0 ; i < n ; i ++) {
f r e e (Ax [ i ] ) ;
}
f r e e (Ax ) ;
}

i n t main ( ) {
int n = 3; // N m e r o de v a r i v e i s
int k = 2; // N m e r o de s i s t e m a s
d o u b l e ∗∗ A = ( double ∗∗) malloc (n ∗ s i z e o f ( double ∗ ) ) ;
for ( int i = 0 ; i < n ; i ++) {
A[ i ] = ( double ∗) malloc (n ∗ s i z e o f ( double ) ) ;
}

A [ 0 ] [ 0 ] = 2 ; A [ 0 ] [ 1 ] = 1 ; A [ 0 ] [ 2 ] = −1;
A [ 1 ] [ 0 ] = −3; A [ 1 ] [ 1 ] = −1; A [ 1 ] [ 2 ] = 2 ;
A [ 2 ] [ 0 ] = −2; A [ 2 ] [ 1 ] = 1 ; A [ 2 ] [ 2 ] = 2 ;

double ∗ b = ( double ∗) malloc ( k ∗ n ∗ s i z e o f ( double ) ) ;

b [ 0 ] = 8 ; b [ 1 ] = −11; b [ 2 ] = −3;
b [ 3 ] = 3; b [ 4 ] = 4; b [ 5 ] = 2;

10
 d o u b l e ∗∗ x = ( d o u b l e ∗ ∗ ) m a l l o c ( n ∗ s i z e o f ( d o u b l e ∗ ) ) ;
f o r ( i n t i = 0 ; i < n ; i ++) {
x [ i ] = ( double ∗) malloc ( k ∗ s i z e o f ( double ) ) ;
}

EGauss (A, b , n , k , x ) ;

p r i n t f (” Resultados : \ n ” ) ;
f o r ( i n t m = 0 ; m < k ; m++) {
p r i n t f (” S o l u o do s i s t e m a %d : ” , m + 1 ) ;
f o r ( i n t i = 0 ; i < n ; i ++) {
p r i n t f (”% f ” , x [ i ] [m] ) ;
}
p r i n t f (”\n ” ) ;
}

f o r ( i n t i = 0 ; i < n ; i ++) {
f r e e (A[ i ] ) ;
free (x [ i ] ) ;
}
f r e e (A ) ;
free (b ) ;
free (x );

return 0;
}

3 Polinômio interpolador
#i n c l u d e <s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e <math . h>

#d e f i n e XF START −1.0
#d e f i n e XF END 1 . 0
#d e f i n e XF STEP 0 . 0 2
#d e f i n e X START −1.0
#d e f i n e X END 1 . 0
#d e f i n e X STEP 0 . 2

double f ( double x ) {
r e t u r n 1 . 0 / ( 1 + 25 ∗ x ∗ x ) ;
}

11
i n t main ( ) {
// D e f i n i n d o o s p o n t o s para c l c u l o e i n t e r p o l a o
i n t n = ( i n t ) ( ( XF END − XF START) / XF STEP) + 1 ; // N m e r o de p o n t o s x f
i n t m = ( i n t ) ( ( X END − X START) / X STEP) + 1 ; // N m e r o de p o n t o s x

double ∗ xf = ( double ∗) malloc (n ∗ s i z e o f ( double ) ) ;

double ∗x = ( d o u b l e ∗ ) m a l l o c (m ∗ s i z e o f ( d o u b l e ) ) ;
double ∗ f v a l s = ( d o u b l e ∗ ) m a l l o c (m ∗ s i z e o f ( d o u b l e ) ) ;
double ∗p = ( d o u b l e ∗ ) m a l l o c ( n ∗ s i z e o f ( d o u b l e ) ) ;

// Preenchendo o s a r r a y s x f e x
f o r ( i n t i = 0 ; i < n ; i ++) {
x f [ i ] = XF START + i ∗ XF STEP ;
}
f o r ( i n t i = 0 ; i < m; i ++) {
x [ i ] = X START + i ∗ X STEP ;
f v a l s [ i ] = f ( x [ i ] ) ; // C a l c u l a n d o f ( x ) nos p o n t o s de i n t e r p o l a o
}

// I n t e r p o l a o de Lagrange
f o r ( i n t s = 0 ; s < n ; s++) {
p[ s ] = 0.0;
f o r ( i n t l = 0 ; l < m; l ++) {
double L = 1 . 0 ;
f o r ( i n t k = 0 ; k < m; k++) {
i f ( k != l ) { // E v i t a d i v i s o por z e r o
L ∗= ( x f [ s ] − x [ k ] ) / ( x [ l ] − x [ k ] ) ;
}
}
p [ s ] += f v a l s [ l ] ∗ L ;
}
}

// E x i b i r r e s u l t a d o s
p r i n t f ( ” Pontos de I n t e r p o l a o :\n”);
f o r ( i n t i = 0 ; i < n ; i ++) {
p r i n t f ( ” x f [%d ] = %.2 f , p[%d ] = %.5 f \n ” , i , x f [ i ] , i , p [ i ] ) ;
}

// Li be ran do m e m r i a
f r e e ( xf ) ;
free (x );
free ( f vals );
free (p ) ;

return 0;

12
}

References
[1] Kernighan, B. W., & Ritchie, D. M. (1988). The C Programming Language.
Prentice Hall.
[2] ISO/IEC. (1999). Programming Language C. ISO/IEC 9899:1999.

[3] ISO/IEC. (2011). Programming Language C. ISO/IEC 9899:2011.

13