Aprender
Linguagem C++

#include <iostream>
#include <string>
using namespace std;

class Saudacao {
    string nome;
public:
    Saudacao(string n) : nome(n) {}

    void dizer() const {
        cout << "Olá, " << nome << "! Bem-vindo ao C++.\n";
    }
};

int main() {
    Saudacao s1("Ana");
    Saudacao s2("Bob");
    s1.dizer();
    s2.dizer();
    return 0;
}

#include <iostream>
#include <stdexcept>
using namespace std;

class Calculadora {
public:
    double somar(double a, double b)       const { return a + b; }
    double subtrair(double a, double b)    const { return a - b; }
    double multiplicar(double a, double b) const { return a * b; }

    double dividir(double a, double b) const {
        if (b == 0.0)
            throw invalid_argument("Divisão por zero!");
        return a / b;
    }
};

int main() {
    Calculadora c;
    cout << c.somar(3, 4)       << "\n"; // 7
    cout << c.multiplicar(5, 6) << "\n"; // 30

    try {
        cout << c.dividir(10, 0) << "\n";
    } catch (const invalid_argument& e) {
        cerr << "Erro: " << e.what() << "\n";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

int main() {
    vector<double> notas = {15.5, 18.0, 12.0, 9.5, 17.0, 14.0};

    double soma  = accumulate(notas.begin(), notas.end(), 0.0);
    double media = soma / notas.size();
    double mx    = *max_element(notas.begin(), notas.end());
    double mn    = *min_element(notas.begin(), notas.end());

    cout << "Média: "  << media << "\n";
    cout << "Máximo: " << mx    << "\n";
    cout << "Mínimo: " << mn    << "\n";
    cout << "Acima da média: ";
    for (double n : notas)
        if (n > media) cout << n << " ";
    cout << "\n";
    return 0;
}

#include <iostream>
#include <vector>
#include <memory>
#include <cmath>
using namespace std;

class Forma {
public:
    virtual double area()     const = 0;
    virtual string tipo()     const = 0;
    virtual ~Forma() = default;

    void info() const {
        cout << tipo() << ": área = "
             << area() << "\n";
    }
};

class Circulo : public Forma {
    double r;
public:
    Circulo(double r) : r(r) {}
    double area() const override { return M_PI * r * r; }
    string tipo() const override { return "Círculo"; }
};

class Retangulo : public Forma {
    double l, a;
public:
    Retangulo(double l, double a) : l(l), a(a) {}
    double area() const override { return l * a; }
    string tipo() const override { return "Retângulo"; }
};

int main() {
    vector<unique_ptr<Forma>> formas;
    formas.push_back(make_unique<Circulo>(5.0));
    formas.push_back(make_unique<Retangulo>(4.0, 3.0));

    for (auto& f : formas) f->info();
    return 0;
}

#include <iostream>
#include <sstream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    string texto = "o rato roeu a roupa do rei de roma o rato";
    map<string, int> freq;

    istringstream ss(texto);
    string palavra;
    while (ss >> palavra) freq[palavra]++;

    // Ordenar por frequência
    vector<pair<string,int>> v(freq.begin(), freq.end());
    sort(v.begin(), v.end(),
        [](auto& a, auto& b){ return a.second > b.second; });

    for (auto& [p, c] : v)
        cout << p << ": " << c << "\n";
    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;

class Vetor3D {
public:
    double x, y, z;
    Vetor3D(double x, double y, double z) : x(x), y(y), z(z) {}

    Vetor3D operator+(const Vetor3D& o) const
        { return {x+o.x, y+o.y, z+o.z}; }
    Vetor3D operator-(const Vetor3D& o) const
        { return {x-o.x, y-o.y, z-o.z}; }

    // Produto escalar
    double operator*(const Vetor3D& o) const
        { return x*o.x + y*o.y + z*o.z; }

    double norma() const
        { return sqrt(x*x + y*y + z*z); }

    friend ostream& operator<<(ostream& os, const Vetor3D& v) {
        return os << "(" << v.x << ", " << v.y << ", " << v.z << ")";
    }
};

int main() {
    Vetor3D a(1,2,3), b(4,5,6);
    cout << "a + b = " << (a+b) << "\n"; // (5, 7, 9)
    cout << "a · b = " << (a*b) << "\n"; // 32
    cout << "|a|  = " << a.norma() << "\n"; // 3.742
}

#include <iostream>
#include <vector>
#include <stdexcept>
using namespace std;

template <typename T>
class Stack {
    vector<T> dados;
public:
    void push(const T& v) { dados.push_back(v); }

    T pop() {
        if (isEmpty()) throw runtime_error("Stack vazia");
        T v = dados.back();
        dados.pop_back();
        return v;
    }

    const T& peek() const {
        if (isEmpty()) throw runtime_error("Stack vazia");
        return dados.back();
    }

    bool   isEmpty() const { return dados.empty(); }
    size_t size()    const { return dados.size(); }
};

int main() {
    Stack<int> s;
    s.push(1); s.push(2); s.push(3);
    cout << s.pop() << "\n";   // 3
    cout << s.peek() << "\n";  // 2
    cout << s.size() << "\n";  // 2
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;

struct No {
    int val;
    unique_ptr<No> prox;
    No(int v) : val(v) {}
};

class Lista {
    unique_ptr<No> head;
public:
    void inserir(int v) {
        auto novo = make_unique<No>(v);
        novo->prox = std::move(head);
        head = std::move(novo);
    }

    void imprimir() const {
        const No* p = head.get();
        while (p) { cout << p->val << " → "; p = p->prox.get(); }
        cout << "null\n";
    }
};

int main() {
    Lista l;
    l.inserir(3); l.inserir(2); l.inserir(1);
    l.imprimir(); // 1 → 2 → 3 → null
    // Sem delete! unique_ptr gere tudo.
}

#include <iostream>
#include <vector>
#include <functional>
using namespace std;

int pipeline(int v, vector<function<int(int)>> fns) {
    for (auto& f : fns) v = f(v);
    return v;
}

int main() {
    auto resultado = pipeline(3, {
        [](int x) { return x * x; },      // 3 → 9
        [](int x) { return x + 1; },      // 9 → 10
        [](int x) { return x * 2; },      // 10 → 20
        [](int x) { return x - 5; }       // 20 → 15
    });
    cout << resultado << "\n"; // 15
    return 0;
}

#include <iostream>
#include <iomanip>
using namespace std;

template <typename T, int R, int C>
class Matriz {
    T dados[R][C]{};
public:
    T& operator()(int r, int c)      { return dados[r][c]; }
    T  operator()(int r, int c) const { return dados[r][c]; }

    Matriz<T,R,C> operator+(const Matriz<T,R,C>& o) const {
        Matriz<T,R,C> res;
        for (int i=0; i<R; i++)
            for (int j=0; j<C; j++)
                res(i,j) = dados[i][j] + o(i,j);
        return res;
    }

    Matriz<T,C,R> transposta() const {
        Matriz<T,C,R> res;
        for (int i=0; i<R; i++)
            for (int j=0; j<C; j++)
                res(j,i) = dados[i][j];
        return res;
    }

    void imprimir() const {
        for (int i=0; i<R; i++) {
            for (int j=0; j<C; j++)
                cout << setw(4) << dados[i][j];
            cout << "\n";
        }
    }
};