Folha de Dicas de Programação em C

Sintaxe Básica e Estrutura

Programa Hello World

Estrutura básica de um programa em C.

#include <stdio.h>
int main() {
    printf("Hello, World!\n");
    return 0;
}

Headers e Preprocessador

Inclua bibliotecas e use diretivas de pré-processador.

#include <stdio.h>    // Entrada/saída padrão
#include <stdlib.h>   // Biblioteca padrão
#include <string.h>   // Funções de string
#include <math.h>     // Funções de matemática
#define PI 3.14159
#define MAX_SIZE 100

Comentários

Comentários de linha única e de múltiplas linhas.

// Comentário de linha única
/*
Comentário de
múltiplas linhas
se estende por várias linhas
*/
// TODO: Implementar funcionalidade
/* FIXME: Bug nesta seção */

Função Main

Ponto de entrada do programa com valores de retorno.

int main() {
    // Código do programa aqui
    return 0;  // Sucesso
}
int main(int argc, char *argv[]) {
    // argc: contagem de argumentos
    // argv: valores dos argumentos (linha de comando)
    return 0;
}

Saída Básica

Exibir texto e variáveis no console.

printf("Hello\n");
printf("Valor: %d\n", 42);
// Múltiplos valores em uma linha
printf("Nome: %s, Idade: %d\n", name, age);

Entrada Básica

Ler a entrada do usuário no console.

int age;
char name[50];
scanf("%d", &age);
scanf("%s", name);
// Ler linha inteira com espaços
fgets(name, sizeof(name), stdin);

Tipos de Dados e Variáveis

Tipos Primitivos

Tipos de dados básicos para armazenar diferentes tipos de valores.

// Tipos inteiros
int age = 25;
short small_num = 100;
long large_num = 1000000L;
long long huge_num = 9223372036854775807LL;
// Tipos de ponto flutuante
float price = 19.99f;
double precise = 3.14159265359;
// Caractere e booleano (usando int)
char grade = 'A';
int is_valid = 1;  // 1 para verdadeiro, 0 para falso

Arrays e Strings

Arrays e manipulação de strings em C.

// Arrays
int numbers[5] = {1, 2, 3, 4, 5};
int matrix[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};
// Strings (arrays de caracteres)
char name[50] = "John Doe";
char greeting[] = "Hello";
char buffer[100];  // Não inicializado
// Comprimento e tamanho da string
int len = strlen(name);
int size = sizeof(buffer);

Constantes e Modificadores

Valores imutáveis e modificadores de armazenamento.

// Constantes
const int MAX_SIZE = 100;
const double PI = 3.14159;
// Constantes de pré-processador
#define BUFFER_SIZE 512
#define TRUE 1
#define FALSE 0
// Modificadores de armazenamento
static int count = 0;     // Variável estática
extern int global_var;    // Variável externa
register int fast_var;    // Dica de registrador

Estruturas de Fluxo de Controle

Declarações Condicionais

Tomar decisões com base em condições.

// Declaração if-else
if (age >= 18) {
    printf("Adulto\n");
} else if (age >= 13) {
    printf("Adolescente\n");
} else {
    printf("Criança\n");
}
// Operador ternário
char* status = (age >= 18) ? "Adulto" : "Menor";
// Declaração switch
switch (grade) {
    case 'A':
        printf("Excelente!\n");
        break;
    case 'B':
        printf("Bom trabalho!\n");
        break;
    default:
        printf("Continue tentando!\n");
}

Laços For

Iterar com laços baseados em contador.

// Laço for tradicional
for (int i = 0; i < 10; i++) {
    printf("%d ", i);
}
// Iteração de array
int numbers[] = {1, 2, 3, 4, 5};
int size = sizeof(numbers) / sizeof(numbers[0]);
for (int i = 0; i < size; i++) {
    printf("%d ", numbers[i]);
}
// Laços aninhados
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d,%d ", i, j);
    }
}

Laços While

Iteração baseada em condição.

// Laço While
int count = 0;
while (count < 5) {
    printf("%d\n", count);
    count++;
}
// Laço Do-while (executa pelo menos uma vez)
int input;
do {
    printf("Digite um número (0 para sair): ");
    scanf("%d", &input);
} while (input != 0);

Controle de Laço

Instruções break e continue.

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue; // Pula iteração
    }
    if (i == 7) {
        break;    // Sai do laço
    }
    printf("%d ", i);
}
// Laços aninhados com break
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == j) break; // Quebra apenas o laço interno
        printf("%d,%d ", i, j);
    }
}

Funções

Declaração e Definição de Função

Criar blocos de código reutilizáveis.

// Declaração de função (protótipo)
int add(int a, int b);
void printMessage(char* msg);
// Definição de função
int add(int a, int b) {
    return a + b;
}
void printMessage(char* msg) {
    printf("%s\n", msg);
}
// Chamada de função
int result = add(5, 3);
printMessage("Hello, functions!");

Passagem de Arrays para Funções

Funções que trabalham com arrays.

// Array como parâmetro (ponteiro)
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
// Modificando elementos do array
void doubleValues(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;
    }
}

Funções Recursivas

Funções que chamam a si mesmas.

// Cálculo de fatorial
int factorial(int n) {
    if (n <= 1) {
        return 1;  // Caso base
    }
    return n * factorial(n - 1);
}
// Sequência de Fibonacci
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n-1) + fibonacci(n-2);
}

Ponteiros de Função

Ponteiros para funções para comportamento dinâmico.

// Declaração de ponteiro de função
int (*operation)(int, int);
// Atribuir função ao ponteiro
operation = add;
int result = operation(5, 3);
// Array de ponteiros de função
int (*operations[])(int, int) = {add, subtract, multiply};
result = operations[0](10, 5);

Ponteiros e Gerenciamento de Memória

Noções Básicas de Ponteiros

Declarar e usar ponteiros para acessar endereços de memória.

int x = 10;
int *ptr = &x;  // Ponteiro para x
printf("Valor de x: %d\n", x);
printf("Endereço de x: %p\n", &x);
printf("Valor de ptr: %p\n", ptr);
printf("Valor apontado por ptr: %d\n", *ptr);
// Modificar valor através do ponteiro
*ptr = 20;
printf("Novo valor de x: %d\n", x);
// Ponteiro nulo
int *null_ptr = NULL;

Arrays e Ponteiros

Relação entre arrays e ponteiros.

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;  // Aponta para o primeiro elemento
// Notação de array vs aritmética de ponteiros
printf("%d\n", arr[2]);   // Notação de array
printf("%d\n", *(p + 2)); // Aritmética de ponteiros
printf("%d\n", p[2]);     // Ponteiro como array
// Iterar usando ponteiro
for (int i = 0; i < 5; i++) {
    printf("%d ", *(p + i));
}

Alocação Dinâmica de Memória

Alocar e desalocar memória em tempo de execução.

#include <stdlib.h>
// Alocar memória para um único inteiro
int *ptr = (int*)malloc(sizeof(int));
if (ptr != NULL) {
    *ptr = 42;
    printf("Valor: %d\n", *ptr);
    free(ptr);  // Sempre libere a memória alocada
}
// Alocar array dinamicamente
int *arr = (int*)malloc(10 * sizeof(int));
if (arr != NULL) {
    for (int i = 0; i < 10; i++) {
        arr[i] = i * i;
    }
    free(arr);
}

Ponteiros de String

Trabalhando com strings e ponteiros de caractere.

// Literais de string e ponteiros
char *str1 = "Hello";           // Literal de string
char str2[] = "World";          // Array de caracteres
char *str3 = (char*)malloc(20); // String dinâmica
// Funções de string
strcpy(str3, "Dynamic");
printf("Comprimento: %lu\n", strlen(str1));
printf("Comparação: %d\n", strcmp(str1, str2));
strcat(str2, "!");
// Sempre libere strings dinâmicas
free(str3);

Estruturas e Tipos Definidos pelo Usuário

Definição de Estrutura

Definir tipos de dados personalizados com múltiplos campos.

// Definição de estrutura
struct Rectangle {
    double width;
    double height;
};
// Estrutura com typedef
typedef struct {
    char name[50];
    int age;
    double gpa;
} Student;
// Criar e inicializar estruturas
struct Rectangle rect1 = {5.0, 3.0};
Student student1 = {"Alice", 20, 3.75};
// Acessar membros da estrutura
printf("Área: %.2f\n", rect1.width * rect1.height);
printf("Estudante: %s, Idade: %d\n", student1.name, student1.age);

Estruturas Aninhadas

Estruturas contendo outras estruturas.

typedef struct {
    int day, month, year;
} Date;
typedef struct {
    char name[50];
    Date birthdate;
    double salary;
} Employee;
Employee emp = {
    "John Smith",
    {15, 6, 1985},
    50000.0
};
printf("Nascido em: %d/%d/%d\n",
       emp.birthdate.day,
       emp.birthdate.month,
       emp.birthdate.year);

Ponteiros para Estruturas

Usar ponteiros para acessar e modificar estruturas.

Student *student_ptr = &student1;
// Acesso usando ponteiro (dois métodos)
printf("Nome: %s\n", (*student_ptr).name);
printf("Idade: %d\n", student_ptr->age);
// Modificar através do ponteiro
student_ptr->age = 21;
strcpy(student_ptr->name, "Alice Johnson");
// Alocação dinâmica de estrutura
Student *new_student = (Student*)malloc(sizeof(Student));
if (new_student != NULL) {
    strcpy(new_student->name, "Bob");
    new_student->age = 19;
    new_student->gpa = 3.2;
    free(new_student);
}

Unions e Enums

Métodos alternativos de organização de dados.

// Union - espaço de memória compartilhado
union Data {
    int integer;
    float floating;
    char character;
};
union Data data;
data.integer = 42;
printf("Inteiro: %d\n", data.integer);
// Enumeração
enum Weekday {
    MONDAY, TUESDAY, WEDNESDAY,
    THURSDAY, FRIDAY, SATURDAY, SUNDAY
};
enum Weekday today = FRIDAY;
printf("Hoje é dia %d\n", today);

Operações de Entrada/Saída de Arquivos

Leitura de Arquivos

Ler dados de arquivos de texto.

#include <stdio.h>
// Ler arquivo inteiro caractere por caractere
FILE *file = fopen("data.txt", "r");
if (file != NULL) {
    int ch;
    while ((ch = fgetc(file)) != EOF) {
        putchar(ch);
    }
    fclose(file);
}
// Ler linha por linha
FILE *file2 = fopen("lines.txt", "r");
char buffer[256];
while (fgets(buffer, sizeof(buffer), file2) != NULL) {
    printf("Linha: %s", buffer);
}
fclose(file2);
// Ler dados formatados
FILE *numbers = fopen("numbers.txt", "r");
int num;
while (fscanf(numbers, "%d", &num) == 1) {
    printf("Número: %d\n", num);
}
fclose(numbers);

Verificação de Erros

Lidar com operações de arquivo com segurança.

FILE *file = fopen("data.txt", "r");
if (file == NULL) {
    printf("Erro ao abrir o arquivo!\n");
    perror("fopen");  // Imprime a mensagem de erro do sistema
    return 1;
}
// Verificar erros de leitura
if (ferror(file)) {
    printf("Erro ao ler o arquivo!\n");
}
// Verificar fim de arquivo
if (feof(file)) {
    printf("Fim do arquivo alcançado\n");
}
fclose(file);

Escrita em Arquivos

Escrever dados em arquivos de texto.

// Escrever no arquivo
FILE *outfile = fopen("output.txt", "w");
if (outfile != NULL) {
    fprintf(outfile, "Hello, file!\n");
    fprintf(outfile, "Número: %d\n", 42);
    fclose(outfile);
}
// Anexar a arquivo existente
FILE *appendfile = fopen("log.txt", "a");
if (appendfile != NULL) {
    fprintf(appendfile, "Nova entrada de log\n");
    fclose(appendfile);
}
// Escrever array no arquivo
int numbers[] = {1, 2, 3, 4, 5};
FILE *numfile = fopen("numbers.txt", "w");
for (int i = 0; i < 5; i++) {
    fprintf(numfile, "%d ", numbers[i]);
}
fclose(numfile);

Operações de Arquivo Binário

Ler e escrever dados binários de forma eficiente.

// Escrever dados binários
Student students[3] = {
    {"Alice", 20, 3.75},
    {"Bob", 21, 3.2},
    {"Charlie", 19, 3.9}
};
FILE *binfile = fopen("students.bin", "wb");
fwrite(students, sizeof(Student), 3, binfile);
fclose(binfile);
// Ler dados binários
Student loaded_students[3];
FILE *readbin = fopen("students.bin", "rb");
fread(loaded_students, sizeof(Student), 3, readbin);
fclose(readbin);

Manipulação de Strings

Funções de String

Operações comuns de string da biblioteca string.h.

#include <string.h>
char str1[50] = "Hello";
char str2[] = "World";
char dest[100];
// Comprimento da string
int len = strlen(str1);
printf("Comprimento: %d\n", len);
// Cópia de string
strcpy(dest, str1);
strncpy(dest, str1, 10); // Copia os primeiros 10 caracteres
// Concatenação de string
strcat(dest, " ");
strcat(dest, str2);
strncat(dest, "!", 1);   // Anexa 1 caractere
// Comparação de string
int result = strcmp(str1, str2);
if (result == 0) {
    printf("Strings são iguais\n");
}

Pesquisa de String

Encontrar substrings e caracteres dentro de strings.

char text[] = "The quick brown fox";
char *ptr;
// Encontrar primeira ocorrência de caractere
ptr = strchr(text, 'q');
if (ptr != NULL) {
    printf("Encontrado 'q' na posição: %ld\n", ptr - text);
}
// Encontrar última ocorrência
ptr = strrchr(text, 'o');
printf("Último 'o' na posição: %ld\n", ptr - text);
// Encontrar substring
ptr = strstr(text, "brown");
if (ptr != NULL) {
    printf("Encontrado 'brown' em: %s\n", ptr);
}

Conversão de String

Converter strings para números e vice-versa.

#include <stdlib.h>
// Conversão de string para número
char num_str[] = "12345";
char float_str[] = "3.14159";
int num = atoi(num_str);
long long_num = atol(num_str);
double float_num = atof(float_str);
printf("Inteiro: %d\n", num);
printf("Longo: %ld\n", long_num);
printf("Duplo: %.2f\n", float_num);
// Número para string (usando sprintf)
char buffer[50];
sprintf(buffer, "%d", 42);
sprintf(buffer, "%.2f", 3.14159);
printf("String: %s\n", buffer);

Processamento Personalizado de String

Técnicas manuais de manipulação de string.

// Contar caracteres na string
int countChar(char *str, char target) {
    int count = 0;
    while (*str) {
        if (*str == target) count++;
        str++;
    }
    return count;
}
// Inverter string no local
void reverseString(char *str) {
    int len = strlen(str);
    for (int i = 0; i < len/2; i++) {
        char temp = str[i];
        str[i] = str[len-1-i];
        str[len-1-i] = temp;
    }
}

Processo de Compilação e Build

Compilação GCC

GNU Compiler Collection para C.

# Compilação básica
gcc -o program main.c
# Com informações de depuração
gcc -g -o program main.c
# Níveis de otimização
gcc -O2 -o program main.c
# Múltiplos arquivos fonte
gcc -o program main.c utils.c math.c
# Incluir diretórios adicionais
gcc -I/usr/local/include -o program main.c
# Ligar bibliotecas
gcc -o program main.c -lm -lpthread

Padrões C

Compilar com versões específicas do padrão C.

# Padrão C90/C89 (ANSI C)
gcc -std=c89 -o program main.c
# Padrão C99
gcc -std=c99 -o program main.c
# Padrão C11 (recomendado)
gcc -std=c11 -o program main.c
# Padrão C18 (mais recente)
gcc -std=c18 -o program main.c
# Habilitar todos os avisos
gcc -Wall -Wextra -std=c11 -o program main.c

Noções Básicas de Makefile

Automatizar a compilação com a utilidade make.

# Makefile Simples
CC = gcc
CFLAGS = -std=c11 -Wall -g
TARGET = program
SOURCES = main.c utils.c
$(TARGET): $(SOURCES)
$(CC) $(CFLAGS) -o $(TARGET) $(SOURCES)
clean:
rm -f $(TARGET)
.PHONY: clean

Melhores Práticas e Dicas

Convenções de Nomenclatura

Nomenclatura consistente torna o código mais legível.

// Variáveis e funções: snake_case
int student_count;
double calculate_average(int scores[], int size);
// Constantes: UPPER_CASE
#define MAX_BUFFER_SIZE 1024
#define PI 3.14159
// Estruturas: PascalCase ou snake_case
typedef struct {
    char name[50];
    int age;
} Student;
// Variáveis globais: prefixo com g_
int g_total_count = 0;
// Parâmetros de função: nomes claros
void process_data(int *input_array, int array_size);

Segurança de Memória

Prevenir bugs comuns relacionados à memória.

// Sempre inicializar variáveis
int count = 0;        // Bom
int count;            // Perigoso - não inicializado
// Verificar retorno de malloc
int *ptr = malloc(sizeof(int) * 10);
if (ptr == NULL) {
    printf("Falha na alocação de memória!\n");
    return -1;
}
// Sempre liberar memória alocada
free(ptr);
ptr = NULL;  // Prevenir reutilização acidental
// Verificação de limites de array
for (int i = 0; i < array_size; i++) {
    // Acesso seguro ao array
    array[i] = i;
}

Dicas de Desempenho

Escrever código C eficiente.

// Usar tipos de dados apropriados
char small_num = 10;   // Para valores pequenos
int normal_num = 1000; // Para inteiros típicos
// Minimizar chamadas de função em laços
int len = strlen(str); // Calcular uma vez
for (int i = 0; i < len; i++) {
    // Processar string
}
// Usar register para variáveis frequentemente acessadas
register int counter;
// Preferir arrays a alocação dinâmica quando o tamanho é conhecido
int fixed_array[100];  // Alocação na pilha
// vs
int *dynamic_array = malloc(100 * sizeof(int));

Organização do Código

Estruturar o código para manutenção.

// Arquivo de cabeçalho (utils.h)
#ifndef UTILS_H
#define UTILS_H
// Protótipos de função
double calculate_area(double radius);
int fibonacci(int n);
// Definições de estrutura
typedef struct {
    int x, y;
} Point;
#endif // UTILS_H
// Arquivo de implementação (utils.c)
#include "utils.h"
#include <math.h>
double calculate_area(double radius) {
    return M_PI * radius * radius;
}

Links Relevantes

• Folha de Dicas de C++
• Folha de Dicas de Java
• Folha de Dicas de Python
• Folha de Dicas de JavaScript
• Folha de Dicas de Golang
• Folha de Dicas de Linux
• Folha de Dicas de Shell
• Folha de Dicas de DevOps