Realizar Operações de Arquivo em C++

Introdução

Neste laboratório, você aprenderá a realizar várias operações de arquivo em C++. O laboratório abrange a abertura de arquivos para leitura e escrita, a escrita de dados de texto em arquivos, a leitura de dados de arquivos de texto, a verificação do status de abertura do arquivo, o tratamento de erros de leitura/escrita de arquivos, o trabalho com arquivos binários, o posicionamento do ponteiro do arquivo e o fechamento de arquivos para liberar recursos. Você ganhará experiência prática no uso das classes fundamentais de fluxo de arquivo (ofstream e ifstream) da biblioteca padrão C++ para interagir com arquivos. Ao final deste laboratório, você terá uma compreensão sólida do manuseio de arquivos na programação C++.

Abrir Arquivos Usando ofstream e ifstream

Nesta etapa, você aprenderá a abrir arquivos em C++ usando duas classes fundamentais de fluxo de arquivo (file stream): ofstream para escrita de arquivos e ifstream para leitura de arquivos. Essas classes fazem parte da biblioteca padrão C++ e fornecem funcionalidades essenciais de manuseio de arquivos.

Primeiro, navegue até o diretório do projeto no terminal do WebIDE:

cd ~/project

Crie um novo arquivo C++ chamado file_operations.cpp:

touch file_operations.cpp

Adicione o seguinte código ao arquivo file_operations.cpp:

#include <iostream>
#include <fstream>  // Inclui o cabeçalho de fluxo de arquivo

int main() {
    // Abrindo um arquivo para escrita usando ofstream
    std::ofstream outputFile("example.txt");

    // Verifica se o arquivo foi aberto com sucesso
    if (outputFile.is_open()) {
        std::cout << "File opened for writing successfully!" << std::endl;
        outputFile.close();  // Fecha o arquivo
    } else {
        std::cout << "Unable to open file for writing." << std::endl;
    }

    // Abrindo um arquivo para leitura usando ifstream
    std::ifstream inputFile("example.txt");

    // Verifica se o arquivo foi aberto com sucesso
    if (inputFile.is_open()) {
        std::cout << "File opened for reading successfully!" << std::endl;
        inputFile.close();  // Fecha o arquivo
    } else {
        std::cout << "Unable to open file for reading." << std::endl;
    }

    return 0;
}

Vamos analisar os conceitos chave:

1. #include <fstream>: Inclui a biblioteca de fluxo de arquivo (file stream)
2. std::ofstream: Fluxo de arquivo de saída (Output File Stream) para escrita em arquivos
3. std::ifstream: Fluxo de arquivo de entrada (Input File Stream) para leitura de arquivos
4. is_open(): Verifica se o arquivo foi aberto com sucesso
5. close(): Fecha o arquivo após as operações

Compile o programa:

g++ file_operations.cpp -o file_operations

Execute o executável:

./file_operations

Saída de exemplo:

File opened for writing successfully!
File opened for reading successfully!

Alguns pontos importantes sobre fluxos de arquivo (file streams):

• Sempre verifique se um arquivo foi aberto com sucesso antes de realizar operações
• Lembre-se de fechar os arquivos depois de terminar de usá-los
• ofstream é usado para escrever em arquivos
• ifstream é usado para ler de arquivos
• Ambas as classes fazem parte do cabeçalho <fstream>

Você pode pensar nos fluxos de arquivo como abrir e fechar portas para os arquivos. ofstream permite que você escreva em uma sala, enquanto ifstream permite que você leia o que está dentro.

Escrever Dados de Texto em Arquivos

Nesta etapa, você aprenderá a escrever dados de texto em arquivos usando a classe ofstream em C++. Com base na etapa anterior, você explorará diferentes maneiras de escrever strings, números e múltiplas linhas em arquivos.

Crie um novo arquivo C++ chamado write_files.cpp:

touch ~/project/write_files.cpp

Adicione o seguinte código ao arquivo write_files.cpp:

#include <iostream>
#include <fstream>
#include <string>

int main() {
    // Abre um arquivo para escrita
    std::ofstream outputFile("student_data.txt");

    // Verifica se o arquivo foi aberto com sucesso
    if (outputFile.is_open()) {
        // Escrevendo uma única string
        outputFile << "John Doe" << std::endl;

        // Escrevendo múltiplos pedaços de dados
        std::string name = "Alice Smith";
        int age = 22;
        double gpa = 3.75;
        outputFile << name << ", " << age << " years old, GPA: " << gpa << std::endl;

        // Escrevendo múltiplas linhas
        outputFile << "Computer Science Student" << std::endl;
        outputFile << "University of Programming" << std::endl;

        // Fecha o arquivo
        outputFile.close();
        std::cout << "Data written to file successfully!" << std::endl;
    } else {
        std::cout << "Unable to open file for writing." << std::endl;
    }

    return 0;
}

Compile o programa:

g++ write_files.cpp -o write_files

Execute o executável:

./write_files

Saída de exemplo:

Data written to file successfully!

Verifique o conteúdo do arquivo:

cat student_data.txt

Conteúdo de exemplo do arquivo:

John Doe
Alice Smith, 22 years old, GPA: 3.75
Computer Science Student
University of Programming

Pontos chave sobre a escrita em arquivos:

• Use o operador << para escrever dados nos arquivos
• std::endl adiciona uma nova linha
• Pode escrever strings, números e variáveis
• Sempre verifique se o arquivo está aberto antes de escrever
• Feche o arquivo após as operações de escrita

Você pode pensar em escrever em arquivos como escrever em um caderno. O ofstream é sua caneta, e o arquivo é a página onde você registra as informações.

Ler Dados de Arquivos de Texto

Nesta etapa, você aprenderá a ler dados de arquivos de texto usando a classe ifstream em C++. Com base nas etapas anteriores, você explorará diferentes métodos para ler linhas, palavras e arquivos inteiros.

Crie um novo arquivo C++ chamado read_files.cpp:

touch ~/project/read_files.cpp

Adicione o seguinte código ao arquivo read_files.cpp:

#include <iostream>
#include <fstream>
#include <string>

int main() {
    // Abre o arquivo criado na etapa anterior
    std::ifstream inputFile("student_data.txt");

    // Verifica se o arquivo foi aberto com sucesso
    if (inputFile.is_open()) {
        // Leitura de linha inteira
        std::string line;
        std::cout << "Reading entire lines:" << std::endl;
        while (std::getline(inputFile, line)) {
            std::cout << line << std::endl;
        }

        // Reinicia o ponteiro do arquivo para o início
        inputFile.clear();
        inputFile.seekg(0, std::ios::beg);

        // Leitura de palavras individuais
        std::cout << "\nReading individual words:" << std::endl;
        std::string word;
        while (inputFile >> word) {
            std::cout << word << " ";
        }
        std::cout << std::endl;

        // Fecha o arquivo
        inputFile.close();
    } else {
        std::cout << "Unable to open file for reading." << std::endl;
    }

    return 0;
}

Compile o programa:

g++ read_files.cpp -o read_files

Execute o executável:

./read_files

Saída de exemplo:

Reading entire lines:
John Doe
Alice Smith, 22 years old, GPA: 3.75
Computer Science Student
University of Programming

Reading individual words:
John Doe Alice Smith, 22 years old, GPA: 3.75 Computer Science Student University of Programming

Pontos chave sobre a leitura de arquivos:

• Use std::getline() para ler linhas inteiras
• Use o operador >> para ler palavras individuais
• clear() e seekg() reiniciam o ponteiro do arquivo
• Sempre verifique se o arquivo está aberto antes de ler
• Feche o arquivo após as operações de leitura

Você pode pensar em ler arquivos como extrair informações de um livro. O ifstream é seu marcador de página, ajudando você a navegar pelo texto.

Verificar Status de Abertura do Arquivo

Nesta etapa, você aprenderá a verificar o status das operações de arquivo em C++ usando vários métodos para verificar se os arquivos foram abertos com sucesso e estão prontos para leitura ou escrita.

Crie um novo arquivo C++ chamado file_status.cpp:

touch ~/project/file_status.cpp

Adicione o seguinte código ao arquivo file_status.cpp:

#include <iostream>
#include <fstream>
#include <string>

int main() {
    // Tenta abrir um arquivo existente para leitura
    std::ifstream inputFile("student_data.txt");

    // Método 1: Usando is_open() para verificar o status do arquivo
    if (inputFile.is_open()) {
        std::cout << "File opened successfully for reading." << std::endl;

        // Realiza operações de leitura
        std::string line;
        while (std::getline(inputFile, line)) {
            std::cout << "Read line: " << line << std::endl;
        }

        inputFile.close();
    } else {
        std::cout << "Failed to open file for reading." << std::endl;
    }

    // Método 2: Usando good() para verificar o estado do arquivo
    std::ofstream outputFile("test_status.txt");

    if (outputFile.good()) {
        std::cout << "File opened successfully for writing." << std::endl;
        outputFile << "Testing file status" << std::endl;

        // Verificações de status adicionais
        if (outputFile) {
            std::cout << "File is in a good state for writing." << std::endl;
        }

        outputFile.close();
    } else {
        std::cout << "Failed to open file for writing." << std::endl;
    }

    // Método 3: Múltiplos métodos de verificação de status
    std::ifstream checkFile("non_existent_file.txt");

    std::cout << "File status checks:" << std::endl;
    std::cout << "is_open(): " << (checkFile.is_open() ? "True" : "False") << std::endl;
    std::cout << "good(): " << (checkFile.good() ? "True" : "False") << std::endl;
    std::cout << "fail(): " << (checkFile.fail() ? "True" : "False") << std::endl;

    return 0;
}

Compile o programa:

g++ file_status.cpp -o file_status

Execute o executável:

./file_status

Saída de exemplo:

File opened successfully for reading.
Read line: John Doe
Read line: Alice Smith, 22 years old, GPA: 3.75
Read line: Computer Science Student
Read line: University of Programming
File opened successfully for writing.
File is in a good state for writing.
File status checks:
is_open(): False
good(): False
fail(): True

Pontos chave sobre a verificação do status do arquivo:

• is_open(): Verifica se o arquivo foi aberto com sucesso
• good(): Verifica se nenhum erro ocorreu
• fail(): Verifica se ocorreu um erro
• Sempre verifique o status do arquivo antes de realizar operações
• Diferentes métodos fornecem várias maneiras de verificar o estado do arquivo

Você pode pensar nas verificações de status de arquivo como uma inspeção de segurança antes de uma viagem. Esses métodos ajudam a garantir que suas operações de arquivo sejam seguras e bem-sucedidas.

Lidar com Erros de Leitura/Escrita de Arquivo

Nesta etapa, você aprenderá a lidar com erros potenciais que podem ocorrer durante operações de leitura e escrita de arquivos em C++. Entender o tratamento de erros é crucial para criar programas robustos de manipulação de arquivos.

Crie um novo arquivo C++ chamado file_error_handling.cpp:

touch ~/project/file_error_handling.cpp

Adicione o seguinte código ao arquivo file_error_handling.cpp:

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>

void writeToFile(const std::string& filename) {
    std::ofstream outputFile(filename);

    // Verifica se o arquivo está aberto
    if (!outputFile) {
        // Lança uma exceção se o arquivo não puder ser aberto
        throw std::runtime_error("Unable to open file for writing: " + filename);
    }

    try {
        // Tenta escrever dados
        outputFile << "Hello, Error Handling!" << std::endl;
        outputFile << "This is a sample text." << std::endl;

        // Simula um erro de escrita (intencionalmente não recomendado)
        if (outputFile.bad()) {
            throw std::runtime_error("Write operation failed");
        }
    }
    catch (const std::exception& e) {
        std::cerr << "Error during writing: " << e.what() << std::endl;
    }

    outputFile.close();
}

void readFromFile(const std::string& filename) {
    std::ifstream inputFile(filename);
    std::string line;

    // Verifica se o arquivo está aberto
    if (!inputFile) {
        // Lança uma exceção se o arquivo não puder ser aberto
        throw std::runtime_error("Unable to open file for reading: " + filename);
    }

    try {
        // Lê e imprime o conteúdo do arquivo
        std::cout << "File contents:" << std::endl;
        while (std::getline(inputFile, line)) {
            std::cout << line << std::endl;
        }

        // Verifica erros de leitura
        if (inputFile.bad()) {
            throw std::runtime_error("Read operation encountered an error");
        }
    }
    catch (const std::exception& e) {
        std::cerr << "Error during reading: " << e.what() << std::endl;
    }

    inputFile.close();
}

int main() {
    try {
        // Escreve em um arquivo
        writeToFile("error_handling_example.txt");

        // Lê do arquivo
        readFromFile("error_handling_example.txt");

        // Tenta ler de um arquivo inexistente
        readFromFile("non_existent_file.txt");
    }
    catch (const std::exception& e) {
        std::cerr << "Main error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

Compile o programa:

g++ file_error_handling.cpp -o file_error_handling

Execute o executável:

./file_error_handling

Saída de exemplo:

File contents:
Hello, Error Handling!
This is a sample text.
Error during reading: Unable to open file for reading: non_existent_file.txt

Pontos chave sobre o tratamento de erros de arquivo:

• Use blocos try-catch para lidar com exceções potenciais
• Verifique o estado do stream do arquivo antes e depois das operações
• Use std::runtime_error para lançar mensagens de erro significativas
• Lide com diferentes tipos de erros relacionados a arquivos
• Forneça mensagens de erro informativas

Você pode pensar no tratamento de erros como uma rede de segurança. Ele captura problemas potenciais e impede que seu programa trave inesperadamente.

Trabalhar com Arquivos Binários Usando fstream

Nesta etapa, você aprenderá a trabalhar com arquivos binários usando a classe fstream em C++. Arquivos binários armazenam dados em seu formato binário bruto, o que é diferente de arquivos de texto e útil para armazenar dados estruturados de forma eficiente.

Crie um novo arquivo C++ chamado binary_files.cpp:

touch ~/project/binary_files.cpp

Adicione o seguinte código ao arquivo binary_files.cpp:

#include <iostream>
#include <fstream>
#include <string>

// Estrutura simples para demonstrar a escrita em arquivo binário
struct Student {
    int id;
    char name[50];
    double gpa;
};

void writeBinaryFile() {
    std::fstream binaryFile("students.bin", std::ios::out | std::ios::binary);

    if (!binaryFile) {
        std::cerr << "Error opening file for writing!" << std::endl;
        return;
    }

    // Cria alguns registros de estudantes
    Student students[3] = {
        {1, "John Doe", 3.5},
        {2, "Alice Smith", 3.8},
        {3, "Bob Johnson", 3.2}
    };

    // Escreve a estrutura inteira no arquivo binário
    binaryFile.write(reinterpret_cast<char*>(students), sizeof(students));

    binaryFile.close();
    std::cout << "Binary file written successfully!" << std::endl;
}

void readBinaryFile() {
    std::fstream binaryFile("students.bin", std::ios::in | std::ios::binary);

    if (!binaryFile) {
        std::cerr << "Error opening file for reading!" << std::endl;
        return;
    }

    Student students[3];

    // Lê a estrutura inteira do arquivo binário
    binaryFile.read(reinterpret_cast<char*>(students), sizeof(students));

    std::cout << "Student Records:" << std::endl;
    for (int i = 0; i < 3; ++i) {
        std::cout << "ID: " << students[i].id
                  << ", Name: " << students[i].name
                  << ", GPA: " << students[i].gpa << std::endl;
    }

    binaryFile.close();
}

int main() {
    // Escreve no arquivo binário
    writeBinaryFile();

    // Lê do arquivo binário
    readBinaryFile();

    return 0;
}

Compile o programa:

g++ binary_files.cpp -o binary_files

Execute o executável:

./binary_files

Saída de exemplo:

Binary file written successfully!
Student Records:
ID: 1, Name: John Doe, GPA: 3.5
ID: 2, Name: Alice Smith, GPA: 3.8
ID: 3, Name: Bob Johnson, GPA: 3.2

Pontos chave sobre arquivos binários:

• Use o flag std::ios::binary para o modo binário
• Métodos write() e read() para dados binários
• reinterpret_cast usado para converter entre tipos
• Útil para armazenar dados estruturados de forma eficiente
• Preserva a representação binária exata dos dados

Você pode pensar em arquivos binários como uma planta precisa. Eles armazenam dados exatamente como existem na memória, sem qualquer conversão de texto.

Posicionar Ponteiro de Arquivo com seekg/seekp

Nesta etapa, você aprenderá a manipular ponteiros de arquivo usando seekg() para leitura e seekp() para escrita em C++. Esses métodos permitem navegar e modificar posições específicas dentro de um arquivo.

Crie um novo arquivo C++ chamado file_pointer.cpp:

touch ~/project/file_pointer.cpp

Adicione o seguinte código ao arquivo file_pointer.cpp:

#include <iostream>
#include <fstream>
#include <string>

void createSampleFile() {
    std::ofstream file("numbers.txt");
    for (int i = 1; i <= 10; ++i) {
        file << i << " ";
    }
    file.close();
}

void demonstrateSeekOperations() {
    // Abre o arquivo em modo de leitura e escrita
    std::fstream file("numbers.txt", std::ios::in | std::ios::out);

    if (!file) {
        std::cerr << "Error opening file!" << std::endl;
        return;
    }

    // Operações de leitura
    std::cout << "Reading operations:" << std::endl;

    // Move para o 5º byte (posição do caractere)
    file.seekg(5);
    int value;
    file >> value;
    std::cout << "Value at 5th byte: " << value << std::endl;

    // Move para o início do arquivo
    file.seekg(0);
    file >> value;
    std::cout << "First value: " << value << std::endl;

    // Operações de escrita
    std::cout << "\nWriting operations:" << std::endl;

    // Move para uma posição específica e escreve
    file.seekp(0);
    file << "100 ";

    // Redefine o ponteiro do arquivo e lê para verificar
    file.seekg(0);
    file >> value;
    std::cout << "Modified first value: " << value << std::endl;

    file.close();
}

int main() {
    // Cria um arquivo de exemplo com números
    createSampleFile();

    // Demonstra as operações seek
    demonstrateSeekOperations();

    return 0;
}

Compile o programa:

g++ file_pointer.cpp -o file_pointer

Execute o executável:

./file_pointer

Saída de exemplo:

Reading operations:
Value at 5th byte: 4
First value: 1

Writing operations:
Modified first value: 100

Pontos chave sobre ponteiros de arquivo:

• seekg(): Move o ponteiro de leitura (get pointer)
• seekp(): Move o ponteiro de escrita (put pointer)
• O primeiro argumento é a posição em bytes
• Útil para acesso aleatório em arquivos
• Pode navegar para locais específicos

Você pode pensar nos ponteiros de arquivo como um cursor em um editor de texto. seekg() e seekp() ajudam você a mover este cursor precisamente para onde deseja.

Fechar Arquivos e Liberar Recursos

Nesta etapa, você aprenderá sobre a importância de fechar arquivos corretamente e gerenciar recursos em C++ para evitar vazamentos de memória e garantir um manuseio eficiente de arquivos. Você explorará diferentes métodos de fechamento de arquivos e o uso dos princípios RAII (Resource Acquisition Is Initialization - Aquisição de Recurso é Inicialização).

Crie um novo arquivo C++ chamado file_resources.cpp:

touch ~/project/file_resources.cpp

Adicione o seguinte código ao arquivo file_resources.cpp:

#include <iostream>
#include <fstream>
#include <string>
#include <memory>

// Fechamento manual de arquivo
void manualFileHandling() {
    std::ofstream outputFile("manual_file.txt");

    if (outputFile.is_open()) {
        outputFile << "Manually managed file resource" << std::endl;

        // Fecha explicitamente o arquivo
        outputFile.close();

        std::cout << "File closed manually." << std::endl;
    }
}

// Manuseio de arquivo baseado em RAII usando unique_ptr
void raii_fileHandling() {
    try {
        // Usando unique_ptr para gerenciar o recurso de arquivo
        std::unique_ptr<std::ofstream> file(new std::ofstream("raii_file.txt"));

        if (file && file->is_open()) {
            *file << "RAII-managed file resource" << std::endl;
            std::cout << "RAII file handling successful." << std::endl;
        }
        // O arquivo é fechado automaticamente quando o unique_ptr sai do escopo
    }
    catch (const std::exception& e) {
        std::cerr << "Error in RAII file handling: " << e.what() << std::endl;
    }
}

// Manuseio de arquivo baseado em escopo
void scopeBasedFileHandling() {
    {
        // O arquivo será fechado automaticamente quando sair do escopo
        std::ofstream scopedFile("scoped_file.txt");

        if (scopedFile.is_open()) {
            scopedFile << "Scope-based file resource management" << std::endl;
            std::cout << "Scoped file handling successful." << std::endl;
        }
    } // O arquivo é fechado automaticamente aqui
}

int main() {
    // Demonstra diferentes técnicas de gerenciamento de recursos de arquivo
    manualFileHandling();
    raii_fileHandling();
    scopeBasedFileHandling();

    return 0;
}

Compile o programa:

g++ file_resources.cpp -o file_resources

Execute o executável:

./file_resources

Saída de exemplo:

File closed manually.
RAII file handling successful.
Scoped file handling successful.

Pontos chave sobre fechar arquivos e gerenciar recursos:

• Sempre feche arquivos após o uso
• Use o método close() para fechamento manual
• Aproveite os princípios RAII
• Use gerenciamento de recursos baseado em escopo
• Prevenir vazamentos de recursos
• Lidar com exceções durante operações de arquivo

Você pode pensar em recursos de arquivo como pegar um livro emprestado de uma biblioteca. Sempre devolva o livro (feche o arquivo) quando terminar para manter a biblioteca (recursos do sistema) organizada.

Resumo

Neste laboratório, você aprendeu a abrir arquivos em C++ usando as classes ofstream e ifstream da biblioteca padrão. Você explorou o processo de verificar o status de abertura do arquivo, escrever dados de texto em arquivos e ler dados de arquivos de texto. Além disso, você obteve uma compreensão sobre como lidar com erros de leitura/escrita de arquivos, trabalhar com arquivos binários usando fstream, posicionar o ponteiro do arquivo com seekg/seekp e fechar arquivos corretamente, liberando recursos. Essas operações fundamentais de arquivo são essenciais para gerenciar o armazenamento e a recuperação de dados em aplicações C++.