Funções, arrays e texto

Uma função de contagem pode receber as notas já lidas e devolver um total. Não trata a entrada nem imprime.

O contrato diz que dados recebe, se os pode alterar e que resultado devolve. Separar estas decisões permite testar a contagem sem fornecer dados pelo teclado.

Parâmetros e argumentos

Os parâmetros são os nomes declarados na função: a e b em int maximo(int a, int b). Os argumentos são as expressões fornecidas na chamada: 4 e 9 em maximo(4, 9). O parâmetro recebe uma cópia ou acesso conforme o contrato; o argumento diz qual o valor ou objeto usado nessa chamada.

Declarar e chamar funções

A declaração int maximo(int a, int b); anuncia o tipo do resultado e dos parâmetros. A definição acrescenta o corpo. A declaração tem de estar visível antes da chamada; a definição necessária tem de existir quando o programa é ligado.

// Excerto: definição de uma função.
int maximo(int a, int b) {
    return a > b ? a : b;
}

O operador condicional condicao ? a : b escolhe a se a condição é verdadeira e b caso contrário. Aqui 4 > 9 é falso, por isso maximo(4, 9) devolve 9; return termina a chamada sem imprimir, por isso o chamador decide se guarda, calcula ou imprime. Uma função void não devolve valor.

Uma sobrecarga usa o mesmo nome com listas de parâmetros diferentes. O compilador escolhe pela chamada; o tipo de retorno, por si só, não distingue duas sobrecargas. Argumentos por defeito permitem omitir os últimos argumentos, por exemplo void imprimir(int n, char separador = ' ');. O valor por defeito tem de estar visível no ponto da chamada. Não o repitas na definição se já o declaraste num cabeçalho.

Valor, referência e const

#include <iostream>
#include <string>

void incrementar_copia(int x) { ++x; }
void incrementar(int& x) { ++x; }
std::size_t comprimento(const std::string& texto) { return texto.size(); }

int main() {
    int n = 4;
    incrementar_copia(n);
    std::cout << n << "\n";
    incrementar(n);
    std::cout << n << " " << comprimento("Ana Maria") << "\n";
}

Saída:

4
5 9

n começa em 4. incrementar_copia(n) cria um parâmetro independente com o valor 4. Incrementar esse parâmetro não toca em n, que continua 4.

incrementar(n) recebe uma referência ao original e deixa n com 5. comprimento("Ana Maria") conta 9 unidades: 3 de Ana, 1 espaço e 5 de Maria.

Uma referência é um nome alternativo para um objeto. Tem de ser inicializada e nunca muda de destino. Atribuir à referência altera o objeto referido.

const T& impede alterações através dessa referência; não torna constantes todas as outras formas de acesso ao objeto. Evitar uma cópia de um int raramente justifica uma referência.

Retornar um std::string por valor é seguro e permite ao compilador evitar cópias. Retornar uma referência a uma variável local deixa acesso a um objeto que já morreu.

Parâmetros apontadores

A secção seguinte passa arrays como const int* valores, que se lê assim: valores guarda o endereço do primeiro inteiro e valores[i] acede ao elemento nessa posição. Ainda não precisas de aritmética de apontadores, que a página Apontadores e memória explica depois com objetos e setas.

Arrays C e dimensões

Um array int v[4] contém quatro inteiros contíguos. Os índices válidos são 0, 1, 2 e 3. v[4] está fora do array. Um array não aumenta de tamanho e não transporta automaticamente o seu comprimento quando é passado como argumento.

Numa lista de parâmetros, const int valores[] é ajustado para const int* valores. Por isso, a função abaixo recebe também n. std::size_t, de <cstddef>, é o tipo inteiro sem sinal usado para tamanhos e índices. Não representa valores negativos.

#include <cstddef>
#include <iostream>

int soma(const int* valores, std::size_t n) {
    int total = 0;
    for (std::size_t i = 0; i < n; ++i) total += valores[i];
    return total;
}

int main() {
    int valores[] = {4, -2, 7, 1};
    std::cout << soma(valores, 4) << "\n";
    std::cout << soma(valores + 1, 2) << "\n";
    std::cout << soma(nullptr, 0) << "\n";
}

Saída:

10
5
0

O contrato de soma exige n elementos válidos e que todas as somas parciais caibam em int. Na segunda chamada, o intervalo contém -2 e 7, por isso soma 5. Na chamada vazia, o ciclo não desreferencia o apontador.

O índice i é relativo ao início recebido. Na segunda chamada, valores[0] dentro da função é o -2 que está no índice 1 do array do chamador.

sizeof(valores) dentro desta função mede o apontador, não o array do chamador. Para um tamanho fixo com interface que o conserva, usa std::array<T, N>. Para tamanho variável, usa std::vector<T>. Um std::vector<int> guarda uma sequência de inteiros; std::vector<int> v{4, -2, 7} cria três elementos. A página Templates e STL desenvolve esta coleção.

Um for por intervalo, como for (int x : valores), visita cada elemento de um array cujo tamanho é conhecido ou de uma coleção. x recebe uma cópia de cada inteiro; alterar x não altera o elemento. Com for (int& x : valores), x refere-se ao elemento e permite alterá-lo. Um apontador isolado não fornece o tamanho para este percurso.

Para percorrer índices de trás para a frente com std::size_t, que não representa negativos, começa em size() e repete enquanto i > 0. Decrementa primeiro e lê v[i]; em alternativa, lê v[i - 1] e só depois decrementa. Qualquer das ordens evita subtrair um a zero e evita testar i >= 0, que num tipo sem sinal nunca falha.

for (std::size_t i = n; i > 0; ) {
    --i;
    std::cout << valores[i] << '\n';
}

O exercício de inverter texto treina este percurso com uma string.

Um array C multidimensional tem os elementos da última dimensão contíguos. Em int matriz[2][3], há duas linhas de três inteiros. Percorre com dois índices, um por dimensão:

// Excerto: soma todos os elementos de uma matriz 2x3.
int soma_matriz(const int matriz[][3], int linhas) {
    int total = 0;
    for (int l = 0; l < linhas; ++l)
        for (int c = 0; c < 3; ++c) total += matriz[l][c];
    return total;
}

Com {{1, 2, 3}, {4, 5, 6}}, a soma é 21. Uma função que recebe const int matriz[][3] precisa de conhecer a dimensão interior para avançar entre linhas. Isto não equivale a int**: um apontador para linhas de três inteiros e um apontador para apontadores têm representações e tipos diferentes.

Arrays de entrada e de saída

Uma função pode escrever o resultado num array reservado pelo chamador e devolver quantas posições ficaram válidas. O tamanho físico e o número de resultados são diferentes: se há espaço para seis inteiros mas só quatro foram escritos, só essas quatro posições pertencem à saída.

Vamos conservar todas as ocorrências dos valores repetidos, pela ordem original. Em 4, 9, 4, 2, 9, 7, o resultado é 4, 9, 4, 9, não apenas os valores distintos 4, 9. A ocorrência final de 4 também conta, mesmo sem outro 4 depois dela: existe uma ocorrência anterior.

O contrato exige n >= 0, uma entrada com n elementos e uma saída com capacidade para pelo menos n. Os arrays não se sobrepõem e a origem fica intacta. Para n == 0, a função não lê nem escreve, por isso aceita apontadores nulos. Neste algoritmo, usamos só ciclos e arrays, como num enunciado que não permite contentores ou funções da biblioteca.

#include <iostream>

// n >= 0; entrada e saida nao se sobrepoem, com n posicoes validas.
int filtrar_repetidos(const int entrada[], int n, int saida[]) {
    int usados = 0;
    for (int i = 0; i < n; ++i) {
        bool repetido = false;
        for (int j = 0; j < n; ++j) {
            if (i != j && entrada[i] == entrada[j]) {
                repetido = true;
                break;
            }
        }
        if (repetido) saida[usados++] = entrada[i];
    }
    return usados;
}

int main() {
    int entrada[] = {4, 9, 4, 2, 9, 7};
    int saida[6];
    int usados = filtrar_repetidos(entrada, 6, saida);
    std::cout << usados << ":";
    for (int i = 0; i < usados; ++i) std::cout << " " << saida[i];
    std::cout << "\n";
    std::cout << filtrar_repetidos(nullptr, 0, nullptr) << "\n";
}

Saída:

4: 4 9 4 9
0

Para cada índice i, procuramos um índice diferente j com o mesmo valor. Não basta comparar o elemento consigo próprio, nem procurar só à sua direita. Ao encontrar uma correspondência, copiamos entrada[i] uma única vez para saida[usados] e avançamos usados.

Antes da iteração i, o prefixo de saida com índices em [0, usados) contém exatamente as ocorrências que passaram o critério nos índices anteriores. Percorrer i por ordem conserva a ordem de entrada. O pior caso faz uma procura linear para cada elemento, com custo quadrático em n; a memória adicional da função é constante, além do destino recebido. A capacidade disponível não inicializa a cauda nem a transforma em resultados. O chamador usa o número devolvido para a percorrer.

Structs e tipos compostos

// Excerto: tipo e acesso aos seus campos.
struct Ponto {
    double x;
    double y;
};
Ponto p{2.0, 3.0};

A struct reúne campos que descrevem um valor: Ponto é um tipo, p é um objeto desse tipo e p.x vale 2.0. O compilador pode introduzir padding, bytes entre campos ou no fim para alinhar os objetos. Por isso, sizeof(Ponto) não deve ser deduzido somando tamanhos de campos. Não graves a memória bruta de uma struct como formato portátil de ficheiro.

struct e class permitem membros e métodos. A diferença sintática central é o acesso por defeito: público na struct, privado na class. Uma enumeração com âmbito, como enum class Estado { livre, ocupado };, cria valores nomeados e evita confundir um estado com um inteiro qualquer.

Strings e linhas

std::string guarda uma sequência de unidades char. size() conta essas unidades, não caracteres Unicode visuais. Para ler ou alterar unidades do texto, usa índices de 0 a size() - 1; numa string vazia não há nenhuma. at() verifica esse limite e lança uma exceção. texto[texto.size()] permite consultar o terminador nulo, mas não é mais uma unidade do texto nem permite guardar outro carácter nessa posição. + concatena strings e == compara o conteúdo. substr(pos, quantidade) extrai uma parte; find devolve uma posição ou std::string::npos quando não encontra.

Depois de >> ler um número, o fim de linha pode continuar na entrada, por isso um getline imediato leria esse resto vazio. Neste formato, a idade ocupa a primeira linha e o nome a segunda. Descarta o resto da primeira linha antes de leres o nome.

#include <iostream>
#include <limits>
#include <string>

int main() {
    int idade = 0;
    if (!(std::cin >> idade)) {
        std::cout << "Idade invalida\n";
        return 0;
    }
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    std::string nome;
    if (!std::getline(std::cin, nome)) {
        std::cout << "Nome em falta\n";
        return 0;
    }
    std::cout << nome << " | " << idade << " | " << nome.size() << "\n";
}

Saída:

Ana Maria | 19 | 9

ignore descarta até ao \n, incluindo-o. std::getline guarda os espaços interiores e retira o terminador. A alternativa getline(std::cin >> std::ws, nome) descarta também espaços iniciais e linhas vazias; só a uses quando isso corresponde ao formato pretendido.

Para separar campos dentro de uma linha, find localiza um separador e substr extrai cada parte. Com s = "azul,verde", s.find(',') devolve 4. s.substr(0, 4) é "azul" e s.substr(5) é "verde". Quando find não encontra o carácter, devolve std::string::npos; nesse caso não há segundo campo.

Strings de C e o terminador

Uma string de C é uma sequência de char terminada por \0. O array char nome[] = "Ana"; tem quatro posições: A, n, a, \0. O terminador não aparece no texto impresso, mas ocupa memória. <cstring> fornece strlen, que percorre até ao terminador, e operações de cópia. Estas funções exigem que os apontadores e capacidades estejam corretos.

Arrays de char comparados com == não comparam o texto, comparam endereços depois da conversão para apontadores. Usa std::string, ou std::strcmp quando o contrato pede strings de C válidas. strcpy não verifica o tamanho do destino. Reservar só três posições para copiar "Ana" é insuficiente.

Presença de letras em dois textos

Agora queremos as letras que aparecem num dos textos, mas não nos dois. Trata-se da diferença simétrica dos conjuntos de letras. Contar repetições ou retirar caracteres na ordem em que aparecem responderia a outra pergunta.

O alfabeto deste exemplo tem as 26 letras de a a z; a maiúscula correspondente conta como a mesma letra. Espaços, números e pontuação são ignorados. Não estamos a tratar todo o texto Unicode. As duas entradas são strings de C válidas, não nulas, com até 1000 unidades char. O destino não se sobrepõe às entradas e tem pelo menos 27 posições: uma por letra possível e outra para \0.

Guardamos duas tabelas de presença, inicialmente falsas. Depois de ler um texto, em_a[i] diz se a letra de índice i apareceu pelo menos uma vez. Marcar novamente a mesma posição não muda o conjunto. indice_letra procura em dois alfabetos explícitos, sem depender de subtrair códigos dos caracteres nem de chamar uma função da biblioteca.

#include <iostream>

int indice_letra(char letra) {
    const char minusculas[] = "abcdefghijklmnopqrstuvwxyz";
    const char maiusculas[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    for (int i = 0; i < 26; ++i)
        if (letra == minusculas[i] || letra == maiusculas[i]) return i;
    return -1;
}

// texto e uma string de C valida com, no maximo, 1000 unidades char.
void marcar_letras(const char texto[], bool presentes[]) {
    for (int i = 0; texto[i] != '\0'; ++i) {
        int indice = indice_letra(texto[i]);
        if (indice >= 0) presentes[indice] = true;
    }
}

// a e b sao validas; saida tem 27 posicoes e nao se sobrepoe as entradas.
int diferenca_letras(const char a[], const char b[], char saida[]) {
    bool em_a[26]{};
    bool em_b[26]{};
    marcar_letras(a, em_a);
    marcar_letras(b, em_b);
    const char alfabeto[] = "abcdefghijklmnopqrstuvwxyz";
    int usados = 0;
    for (int i = 0; i < 26; ++i)
        if (em_a[i] != em_b[i]) saida[usados++] = alfabeto[i];
    saida[usados] = '\0';
    return usados;
}

int main() {
    char saida[27];
    int n = diferenca_letras("ac AB!", "B-cd", saida);
    std::cout << n << " [" << saida << "]\n";
    n = diferenca_letras("abAB", "ba", saida);
    std::cout << n << " [" << saida << "]\n";
}

Saída:

2 [ad]
0 []

Em "ac AB!", ficam presentes a, b, c; em "B-cd", b, c, d. As letras b e c aparecem nos dois e são excluídas. A condição em_a[i] != em_b[i] é verdadeira só para a e d. Percorrer a tabela do índice 0 ao 25 escreve o resultado alfabeticamente, uma vez por letra, sem ordenar o texto original.

No segundo caso, "abAB" repete letras que "ba" contém uma vez, mas os conjuntos são iguais. A saída é vazia e continua a precisar de saida[0] = '\0'. O número devolvido conta letras, sem incluir o terminador. No maior resultado, escrevemos 26 letras e o terminador na posição 26; reservar só 26 posições falharia precisamente nesse caso.

A procura de cada unidade percorre no máximo 26 posições do alfabeto, comparando maiúscula e minúscula. No fim, percorremos as 26 presenças. Com este alfabeto fixo, o tempo é linear no comprimento total dos textos e a memória adicional é constante. O algoritmo não usa string, set, sort nem tolower; o main apenas usa cout para mostrar o resultado. As ferramentas permitidas fazem parte do enunciado, além do resultado esperado.

Recursão e progresso

Uma função recursiva chama-se a si própria e precisa de um caso base com uma medida que diminua até esse caso. A soma recursiva de 1 até n pode usar soma(0) = 0 e soma(n) = n + soma(n - 1) para n > 0. O contrato exige n >= 0 e uma soma representável no tipo escolhido. Se não tratares 0, podes criar chamadas sem fim.

Para n = 3, a descida constrói chamadas e a subida combina resultados:

A descida reduz n e a subida combina os resultados. Uma entrada negativa nunca se aproxima do caso base.

Cada chamada conserva os seus parâmetros e variáveis locais. Um grande número de chamadas pode esgotar a pilha. Quando um ciclo resolve o mesmo problema com um acumulador, não precisas de recursão. Usa-a quando a decomposição do problema a torna clara, não como substituição automática de qualquer ciclo.