Manipulação de Arrays e Strings em C++

Introdução

Neste laboratório, você aprenderá como manipular arrays e strings em C++. O laboratório cobre uma variedade de tópicos, incluindo a criação e inicialização de arrays unidimensionais, acesso e modificação de elementos de array, implementação de arrays bidimensionais, trabalho com strings no estilo C e a classe String, ordenação de elementos de array, realização de busca linear e tratamento de entrada de string com getline(). Através destes exercícios práticos, você desenvolverá uma forte compreensão das operações fundamentais de array e string na programação C++.

Criar e Inicializar Arrays Unidimensionais

Nesta etapa, você aprenderá como criar e inicializar arrays unidimensionais em C++. Arrays são estruturas de dados fundamentais que permitem armazenar múltiplos elementos do mesmo tipo em uma localização contígua de memória.

Abra o WebIDE e crie um novo arquivo chamado arrays_intro.cpp no diretório ~/project. Exploraremos diferentes maneiras de inicializar arrays.

touch ~/project/arrays_intro.cpp

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

#include <iostream>

int main() {
    // Method 1: Declare and initialize an array with specific size
    int numbers[5] = {10, 20, 30, 40, 50};

    // Method 2: Let compiler determine array size
    int scores[] = {85, 92, 78, 95, 88};

    // Method 3: Initialize array with default value zero
    int zeros[6] = {0};

    // Method 4: Create an array and initialize later
    int temperatures[4];
    temperatures[0] = 72;
    temperatures[1] = 68;
    temperatures[2] = 75;
    temperatures[3] = 80;

    // Print array elements
    std::cout << "First method - numbers array:" << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "Element " << i << ": " << numbers[i] << std::endl;
    }

    return 0;
}

Vamos detalhar a inicialização de arrays:

1. int numbers[5] = {10, 20, 30, 40, 50};: Define explicitamente o tamanho do array e inicializa todos os elementos.
2. int scores[] = {85, 92, 78, 95, 88};: Deixa o compilador determinar o tamanho do array.
3. int zeros[6] = {0};: Inicializa todos os elementos com zero.
4. Atribui valores manualmente usando o índice temperatures[index] = value.

Compile e execute o programa:

g++ arrays_intro.cpp -o arrays_intro
./arrays_intro

Exemplo de saída:

First method - numbers array:
Element 0: 10
Element 1: 20
Element 2: 30
Element 3: 40
Element 4: 50

Pontos chave sobre arrays:

• Arrays têm um tamanho fixo uma vez declarados.
• A indexação do array começa em 0.
• Você pode inicializar arrays de várias maneiras.
• Sempre certifique-se de não exceder os limites do array (array bounds).

Acessar e Modificar Elementos de Array Usando Índice

Nesta etapa, você aprenderá como acessar e modificar elementos de array usando seu índice em C++. Com base na etapa anterior de inicialização de array, exploraremos como interagir com elementos individuais do array.

Abra o WebIDE e crie um novo arquivo chamado array_indexing.cpp no diretório ~/project:

touch ~/project/array_indexing.cpp

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

#include <iostream>

int main() {
    // Create an array of student scores
    int scores[5] = {85, 92, 78, 95, 88};

    // Accessing array elements by index
    std::cout << "First student's score: " << scores[0] << std::endl;
    std::cout << "Third student's score: " << scores[2] << std::endl;

    // Modifying array elements
    std::cout << "Original second student's score: " << scores[1] << std::endl;
    scores[1] = 96; // Update the second student's score
    std::cout << "Updated second student's score: " << scores[1] << std::endl;

    // Calculating array element sum
    int total_score = 0;
    for (int i = 0; i < 5; i++) {
        total_score += scores[i];
    }
    std::cout << "Total class score: " << total_score << std::endl;

    // Average score calculation
    double average_score = static_cast<double>(total_score) / 5;
    std::cout << "Average class score: " << average_score << std::endl;

    return 0;
}

Pontos chave sobre indexação de array:

• Índices de array começam em 0
• Use colchetes [] para acessar elementos
• Você pode ler e modificar elementos usando seu índice
• Tenha cuidado para não acessar índices fora dos limites do array

Compile e execute o programa:

g++ array_indexing.cpp -o array_indexing
./array_indexing

Exemplo de saída:

First student's score: 85
Third student's score: 78
Original second student's score: 92
Updated second student's score: 96
Total class score: 442
Average class score: 88.4

Regras importantes de indexação:

• O primeiro elemento está no índice 0
• O último elemento está no índice (tamanho do array - 1)
• Acessar um índice fora do intervalo do array causa comportamento indefinido

Implementar Arrays Bidimensionais para Matriz

Nesta etapa, você aprenderá como criar e trabalhar com arrays bidimensionais em C++. Arrays bidimensionais são como tabelas ou matrizes com linhas e colunas, permitindo que você armazene e manipule dados em uma estrutura semelhante a uma grade.

Abra o WebIDE e crie um novo arquivo chamado matrix_arrays.cpp no diretório ~/project:

touch ~/project/matrix_arrays.cpp

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

#include <iostream>

int main() {
    // Method 1: Declare and initialize a 3x3 matrix
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Method 2: Declare matrix and initialize later
    int grades[2][4];
    grades[0][0] = 85;
    grades[0][1] = 92;
    grades[0][2] = 78;
    grades[0][3] = 95;
    grades[1][0] = 88;
    grades[1][1] = 90;
    grades[1][2] = 82;
    grades[1][3] = 87;

    // Print the first matrix
    std::cout << "First Matrix:" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << matrix[row][col] << " ";
        }
        std::cout << std::endl;
    }

    // Print the grades matrix
    std::cout << "\nGrades Matrix:" << std::endl;
    for (int row = 0; row < 2; row++) {
        for (int col = 0; col < 4; col++) {
            std::cout << grades[row][col] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

Pontos chave sobre arrays bidimensionais:

• Use dois índices para acessar elementos: array[row][column]
• O primeiro índice representa a linha, o segundo índice representa a coluna
• Pode ser inicializado de várias maneiras
• Loops aninhados são tipicamente usados para iterar pelas linhas e colunas

Compile e execute o programa:

g++ matrix_arrays.cpp -o matrix_arrays
./matrix_arrays

Exemplo de saída:

First Matrix:
1 2 3
4 5 6
7 8 9

Grades Matrix:
85 92 78 95
88 90 82 87

Conceitos importantes de arrays bidimensionais:

• Arrays podem ter mais de duas dimensões
• Cada linha pode ter um número diferente de colunas
• Sempre tenha cuidado com os limites do array para evitar erros

Inicializar Strings no Estilo C com Terminador Nulo

Nesta etapa, você aprenderá sobre strings no estilo C e a importância do terminador nulo em C++. Strings no estilo C são arrays de caracteres que terminam com um caractere especial '\0' para marcar o fim da string.

Abra o WebIDE e crie um novo arquivo chamado c_style_strings.cpp no diretório ~/project:

touch ~/project/c_style_strings.cpp

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

#include <iostream>
#include <cstring>

int main() {
    // Method 1: Initialize string with explicit null terminator
    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    std::cout << "Greeting: " << greeting << std::endl;

    // Method 2: Initialize as a string literal (automatically adds null terminator)
    char name[] = "John Doe";
    std::cout << "Name: " << name << std::endl;

    // Method 3: Declare with fixed size and initialize
    char message[20] = "Welcome to C++!";
    std::cout << "Message: " << message << std::endl;

    // Demonstrate string length
    std::cout << "Length of name: " << strlen(name) << std::endl;

    // Manual string length calculation
    int length = 0;
    while (name[length] != '\0') {
        length++;
    }
    std::cout << "Manual length of name: " << length << std::endl;

    return 0;
}

Pontos chave sobre strings no estilo C:

• O terminador nulo '\0' marca o fim da string
• Sempre aloque um caractere extra para o terminador nulo
• Literais de string adicionam automaticamente o terminador nulo
• A função strlen() conta os caracteres antes do terminador nulo

Compile e execute o programa:

g++ c_style_strings.cpp -o c_style_strings
./c_style_strings

Exemplo de saída:

Greeting: Hello
Name: John Doe
Message: Welcome to C++!
Length of name: 8
Manual length of name: 8

Conceitos importantes de inicialização de string:

• O terminador nulo é crucial para operações de string
• Sempre garanta espaço suficiente para o terminador nulo
• Tenha cuidado com os tamanhos dos buffers de string para evitar estouro (overflow)

Usar Métodos da Classe String (length, substr, find)

Nesta etapa, você aprenderá sobre os poderosos métodos da classe string em C++ que tornam a manipulação de strings mais fácil e intuitiva. Exploraremos métodos chave como length(), substr() e find().

Abra o WebIDE e crie um novo arquivo chamado string_methods.cpp no diretório ~/project:

touch ~/project/string_methods.cpp

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

#include <iostream>
#include <string>

int main() {
    // Create a string
    std::string message = "Hello, C++ Programming!";

    // Using length() method
    std::cout << "String length: " << message.length() << std::endl;

    // Using substr() method
    std::cout << "First 5 characters: " << message.substr(0, 5) << std::endl;
    std::cout << "Substring from index 7: " << message.substr(7) << std::endl;

    // Using find() method
    std::string search_word = "Programming";
    size_t position = message.find(search_word);

    if (position != std::string::npos) {
        std::cout << "'" << search_word << "' found at index: " << position << std::endl;
    } else {
        std::cout << "Word not found" << std::endl;
    }

    // Additional find() example
    std::string email = "user@example.com";
    size_t at_symbol = email.find('@');
    size_t dot_symbol = email.find('.');

    std::cout << "Username: " << email.substr(0, at_symbol) << std::endl;
    std::cout << "Domain: " << email.substr(at_symbol + 1, dot_symbol - at_symbol - 1) << std::endl;

    return 0;
}

Pontos chave sobre os métodos da classe string:

• length(): Retorna o número de caracteres na string
• substr(): Extrai uma parte da string
  • O primeiro argumento é o índice inicial
  • O segundo argumento (opcional) é o comprimento da substring
• find(): Procura por uma substring ou caractere
  • Retorna o índice da primeira ocorrência
  • Retorna std::string::npos se não for encontrado

Compile e execute o programa:

g++ string_methods.cpp -o string_methods
./string_methods

Exemplo de saída:

String length: 23
First 5 characters: Hello
Substring from index 7: C++ Programming!
'Programming' found at index: 11
Username: user
Domain: example

Conceitos importantes sobre métodos de string:

• Os métodos de string fornecem uma manipulação de texto poderosa
• A indexação começa em 0
• Sempre verifique os valores de retorno para lidar com possíveis erros

Converter entre C-style e Classe String

Nesta etapa, você aprenderá como converter entre strings no estilo C e a classe string do C++. Essas conversões são essenciais ao trabalhar com diferentes representações de string em C++.

Abra o WebIDE e crie um novo arquivo chamado string_conversion.cpp no diretório ~/project:

touch ~/project/string_conversion.cpp

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

#include <iostream>
#include <string>
#include <cstring>

int main() {
    // C-style string to C++ string
    const char* c_style_str = "Hello, C++ World!";
    std::string cpp_string(c_style_str);
    std::cout << "C++ String: " << cpp_string << std::endl;

    // C++ string to C-style string
    std::string message = "Converting strings";
    const char* c_str = message.c_str();
    std::cout << "C-style String: " << c_str << std::endl;

    // Manual conversion using strcpy
    char buffer[50];
    strcpy(buffer, message.c_str());
    std::cout << "Copied to buffer: " << buffer << std::endl;

    // String length comparison
    std::cout << "C++ string length: " << message.length() << std::endl;
    std::cout << "C-style string length: " << strlen(c_str) << std::endl;

    return 0;
}

Métodos chave de conversão:

• std::string(c_style_str): Converte string no estilo C para string C++
• .c_str(): Converte string C++ para string no estilo C
• strcpy(): Copia manualmente a string para um array de caracteres

Compile e execute o programa:

g++ string_conversion.cpp -o string_conversion
./string_conversion

Exemplo de saída:

C++ String: Hello, C++ World!
C-style String: Converting strings
Copied to buffer: Converting strings
C++ string length: 18
C-style string length: 18

Conceitos importantes de conversão:

• Use .c_str() para obter um const char* de uma string C++
• Tenha cuidado com os tamanhos dos buffers ao converter
• strlen() funciona com strings no estilo C
• .length() funciona com strings C++

Ordenar Elementos de Array Usando Bubble Sort

Nesta etapa, você aprenderá como implementar o algoritmo Bubble Sort para ordenar elementos de array em C++. Bubble Sort é um método de ordenação simples que percorre repetidamente a lista, compara elementos adjacentes e os troca se estiverem na ordem errada.

Abra o WebIDE e crie um novo arquivo chamado bubble_sort.cpp no diretório ~/project:

touch ~/project/bubble_sort.cpp

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

#include <iostream>

int main() {
    // Initialize an unsorted array
    int numbers[5] = {64, 34, 25, 12, 22};
    int size = 5;

    // Print original array
    std::cout << "Original Array: ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Bubble Sort implementation
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            // Compare adjacent elements
            if (numbers[j] > numbers[j + 1]) {
                // Swap elements
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    // Print sorted array
    std::cout << "Sorted Array: ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Conceitos chave do Bubble Sort:

• Compara elementos adjacentes
• Troca elementos se estiverem na ordem errada
• Repete as passagens pelo array até que esteja ordenado
• Complexidade de tempo: O(n²)

Compile e execute o programa:

g++ bubble_sort.cpp -o bubble_sort
./bubble_sort

Exemplo de saída:

Original Array: 64 34 25 12 22
Sorted Array: 12 22 25 34 64

Notas importantes sobre ordenação:

• Bubble Sort é simples, mas ineficiente para arrays grandes
• Bom para fins educacionais
• Existem algoritmos de ordenação mais eficientes para aplicações do mundo real

Implementar Busca Linear em Arrays

Nesta etapa, você aprenderá como implementar um algoritmo de Busca Linear (Linear Search) em C++. A Busca Linear é um método simples para encontrar um elemento em um array, verificando cada elemento sequencialmente até que o alvo seja encontrado ou o final do array seja alcançado.

Abra o WebIDE e crie um novo arquivo chamado linear_search.cpp no diretório ~/project:

touch ~/project/linear_search.cpp

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

#include <iostream>

int linearSearch(int arr[], int size, int target) {
    // Iterate through each element in the array
    for (int i = 0; i < size; i++) {
        // Check if current element matches the target
        if (arr[i] == target) {
            return i;  // Return the index if found
        }
    }
    return -1;  // Return -1 if target is not found
}

int main() {
    // Create an array of student scores
    int scores[] = {85, 92, 78, 95, 88, 76, 90};
    int size = sizeof(scores) / sizeof(scores[0]);

    // Target score to search
    int targetScore = 78;

    // Perform linear search
    int result = linearSearch(scores, size, targetScore);

    // Display search results
    if (result != -1) {
        std::cout << "Target score " << targetScore
                  << " found at index " << result << std::endl;
    } else {
        std::cout << "Target score " << targetScore
                  << " not found in the array" << std::endl;
    }

    // Try another search
    int missingScore = 100;
    result = linearSearch(scores, size, missingScore);

    if (result != -1) {
        std::cout << "Score " << missingScore
                  << " found at index " << result << std::endl;
    } else {
        std::cout << "Score " << missingScore
                  << " not found in the array" << std::endl;
    }

    return 0;
}

Conceitos chave da Busca Linear:

• Verifica cada elemento do array sequencialmente
• Retorna o índice do alvo se encontrado
• Retorna -1 se o alvo não estiver no array
• Complexidade de tempo: O(n) - tempo linear
• Simples e funciona para arrays não ordenados

Compile e execute o programa:

g++ linear_search.cpp -o linear_search
./linear_search

Exemplo de saída:

Target score 78 found at index 2
Score 100 not found in the array

Notas importantes sobre busca:

• A Busca Linear é direta, mas ineficiente para arrays grandes
• Adequada para arrays pequenos ou coleções não ordenadas
• Existem algoritmos de busca mais eficientes para arrays ordenados

Manipular Entrada de String com getline()

Nesta etapa, você aprenderá como usar getline() para ler linhas completas de entrada de texto em C++. Diferente de cin >>, getline() pode ler strings com espaços e lidar com cenários de entrada mais complexos.

Abra o WebIDE e crie um novo arquivo chamado getline_input.cpp no diretório ~/project:

touch ~/project/getline_input.cpp

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

#include <iostream>
#include <string>

int main() {
    // Declare a string to store input
    std::string fullName;
    std::string address;

    // Prompt for full name input
    std::cout << "Enter your full name: ";
    std::getline(std::cin, fullName);

    // Prompt for address input
    std::cout << "Enter your full address: ";
    std::getline(std::cin, address);

    // Display input with additional information
    std::cout << "\n--- User Information ---" << std::endl;
    std::cout << "Name: " << fullName << std::endl;
    std::cout << "Address: " << address << std::endl;

    // Demonstrate reading multiple lines
    std::string multiLineText;
    std::cout << "\nEnter a multi-line description (press Ctrl+D to finish):" << std::endl;

    std::string line;
    while (std::getline(std::cin, line)) {
        multiLineText += line + "\n";
    }

    std::cout << "\nYour description:" << std::endl;
    std::cout << multiLineText;

    return 0;
}

Conceitos chave de getline():

• Lê a linha inteira de texto, incluindo espaços
• Sintaxe: std::getline(input_stream, string_variable)
• Pode ler múltiplas linhas de entrada
• Lida com entrada complexa com espaços
• Útil para ler nomes completos, endereços, etc.

Compile o programa:

g++ getline_input.cpp -o getline_input
./getline_input

Exemplo de interação:

Enter your full name: John Michael Smith
Enter your full address: 123 Main Street, Anytown, USA

--- User Information ---
Name: John Michael Smith
Address: 123 Main Street, Anytown, USA

Enter a multi-line description (press Ctrl+D to finish):
This is a sample
multi-line description
with several lines of text.

Your description:
This is a sample
multi-line description
with several lines of text.

Notas importantes sobre manipulação de entrada:

• getline() lê até o caractere de nova linha
• Útil para capturar entrada de texto completa
• Pode ser combinado com outros métodos de entrada

Resumo

Neste laboratório, você aprenderá como criar e inicializar arrays unidimensionais em C++, acessar e modificar elementos de array usando o índice, implementar arrays bidimensionais para matrizes, inicializar strings no estilo C com terminador nulo, usar métodos da classe string, converter entre o estilo C e a classe string, ordenar elementos de array usando bubble sort, implementar busca linear em arrays e manipular entrada de string com getline().

Você explorará diferentes maneiras de inicializar arrays, incluindo especificar o tamanho e inicializar todos os elementos, deixar que o compilador determine o tamanho, inicializar todos os elementos com zero e atribuir valores manualmente usando o índice. Você também aprenderá como acessar e modificar elementos de array usando o índice e como lidar com limites de array para evitar erros. Além disso, você trabalhará com arrays bidimensionais, strings no estilo C e a classe string, aprendendo como converter entre eles e realizar várias operações.