面向 C++98 程序员的 Python 中的 OOP 概念

# privado por convenção: _underscore_simples# "realmente privado": __underscore_duplo (name mangling)# público: sem underscorefrom abc import abstractmethodclass animal(abc):    # em python, variáveis declaradas no escopo da classe e não dentro de um    # método específico, são automaticamente compartilhadas por todas instâncias.    species_count = 0 # além disso, elas podem ser inicializadas diretamente dentro da classe.    # construtor    def __init__(self, name):        # variáveis de instância        self.name = name       # público        self._age = 0          # protegido por convenção        self.__id = id(self)   # privado (mas você consegue acessar com name mangling)        animal.species_count += 1    # destrutor    def __del__(self):        animal.species_count -= 1    # método regular    @abstractmethod    def make_sound(self):        pass  # equivalente a um método abstrato/virtual (deve ser implementado apenas nas classes filhas)    # método estático (não precisa da instância para ser utilizado, nem utiliza seus atributos)    @staticmethod    def get_kingdom():        return "animalia"    # método de classe (recebe a classe como primeiro argumento, pode acessar atributos da classe)    @classmethod    def get_species_count(cls):        return cls.species_count    # decorador de propriedade (getter)    @property    def age(self):        return self._age    # decorador de propriedade (setter)    @age.setter    def age(self, value):        if value >= 0:            self._age = value    # métodos especiais (sobrecarga de operadores)    def __str__(self):                # como tostring() - para string legível        return f"animal named {self.name}"    def __repr__(self):               # para debugging        return f"animal(name='{self.name}')"    def __eq__(self, other):          # operador de comparação ==        return isinstance(other, animal) and self.name == other.name    def __len__(self):                # função len()        return self._age    def __getitem__(self, key):       # operador de acesso []        if key == 'name':            return self.name        raise keyerror(key)

#include <iostream>#include <string>#include <sstream>class animal {public:    static int species_count;    animal(const std::string& name) : name(name), _age(0), __id(++id_counter) { // construtor        ++species_count;    }    ~animal() {    // destrutor        --species_count;    }    virtual void make_sound() = 0; // método não implementável na classe base (virtual/abstrato)    static std::string get_kingdom() {  // não existe distinção entre    //  @classmethod e @staticmethod em cpp, apenas static methods.        return "animalia";    }    // static methods podem ser utilizados sem instanciar uma classe e têm    // acesso às propriedades estáticas da classe:    static int get_species_count() {        return species_count;    }    // getter:    int get_age() const {        return _age;    }    // setter:    void set_age(int age) {        if (age >= 0) {            _age = age;        }    }    // implementação dos métodos especiais que vimos em python:    std::string to_string() const {        return "animal named " + name;    }    std::string repr() const {        std::ostringstream oss;        oss << "animal(name='" << name << "', age=" << _age << ", id=" << __id << ")";        return oss.str();    }    bool operator==(const animal& other) const {        return name == other.name;    }    // sobrecarga do operador []    std::string operator[](const std::string& key) const {        if (key == "name") {            return name;        }        throw std::out_of_range("invalid key");    }    // método isinstance    template <typename t>    bool isinstance() const {        return dynamic_cast<const t*>(this) != nullptr;    }protected:    std::string name;    int _age;private:    int __id;    static int id_counter;};// variáveis estáticas de classe são compartilhadas por todas as instâncias mas// precisam ser inicializadas separadamente.int animal::species_count = 0;int animal::id_counter = 0;

class dog(animal):    def __init__(self, name, breed):        # chama o construtor da classe pai        super().__init__(name)        self.breed = breed    # sobrescreve o método da classe pai    def make_sound(self):        return "woof!"

class dog : public animal {public:    dog(const std::string& name, const std::string& breed) : animal(name), breed(breed) {}    void make_sound() override {        std::cout << "woof!" << std::endl;    }private:    std::string breed;};

class pet:    def is_vaccinated(self):        return trueclass domesticdog(dog, pet):    pass

class pet {public:    bool is_vaccinated() const {        return true;    }};class domesticdog : public dog, public pet {public:    domesticdog(const std::string& name, const std::string& breed) : dog(name, breed) {}};

from abc import abc, abstractmethodclass shape(abc):    @abstractmethod    def area(self):        pass

class shape {public:    virtual ~shape() {}    virtual double area() const = 0;};

if __name__ == "__main__":    # cria objetos    dog = dog("rex", "golden retriever")    # acessa atributos    print(dog.name)          # público    print(dog._age)         # protegido (ainda acessível)    # print(dog.__id)       # isso falhará     print(dog._animal__id)  # isso funciona (acessando attribute privado com name mangling)    # propriedades    dog.age = 5             # usa setter automaticamente    print(dog.age)          # usa getter automaticamente    # métodos estáticos e de classe    print(animal.get_kingdom())    print(animal.get_species_count())    # verifica herança    print(isinstance(dog, animal))  # true    print(issubclass(dog, animal)) # true    # métodos especiais em ação    print(str(dog))        # usa __str__    print(repr(dog))       # usa __repr__    print(len(dog))        # usa __len__    print(dog['name'])     # usa __getitem__

int main() {    // cria objetos    dog dog("rex", "golden retriever");    // acessa atributos    std::cout << dog.name << std::endl;          // público    std::cout << dog.get_age() << std::endl;     // protegido (ainda acessível)    // std::cout << dog.__id << std::endl;       // isso falhará (privado)    // propriedades    dog.set_age(5);             // usa setter    std::cout << dog.get_age() << std::endl;     // usa getter    // métodos estáticos e de classe    std::cout << animal::get_kingdom() << std::endl;    std::cout << animal::get_species_count() << std::endl;    // equivalente aos "métodos especiais":    // verifica herança    if (dog.isinstance<animal>()) {        std::cout << "dog é uma instância de animal" << std::endl;    }    std::cout << dog.to_string() << std::endl;   // usa to_string    std::cout << dog.repr() << std::endl;        // usa repr    std::cout << dog["name"] << std::endl;       // usa operador []}

                              animal                           .    '    ,                             _______                        _  .`_|___|_`.  _                    pet         / /     workinganimal                              ' ' /                               " /                                  ./                           domesticdog

class animal {public:    animal() {        std::cout << "animal constructor" << std::endl;    }    virtual void make_sound() {        std::cout << "some generic animal sound" << std::endl;    }};class pet : public animal {public:    pet() : animal() {        std::cout << "pet constructor" << std::endl;    }    void make_sound() override {        std::cout << "pet sound" << std::endl;    }};class workinganimal : public animal {public:    workinganimal() : animal() {        std::cout << "workinganimal constructor" << std::endl;    }    void make_sound() override {        std::cout << "working animal sound" << std::endl;    }};class domesticdog : public pet, public workinganimal {public:    domesticdog() : animal(), pet(), workinganimal() {        std::cout << "domesticdog constructor" << std::endl;    }    void make_sound() override {        pet::make_sound();  // ou workinganimal::make_sound(), dependendo do comportamento desejado    }};int main() {    domesticdog dog;    dog.make_sound();    return 0;}

animal constructorpet constructorworkinganimal constructordomesticdog constructorpet sound

class animal:    def make_sound(self):        print("some generic animal sound")class pet(animal):    def make_sound(self):        print("pet sound")class workinganimal(animal):    def make_sound(self):        print("working animal sound")class domesticdog(pet, workinganimal):    passdog = domesticdog()dog.make_sound()

pet sound

print(domesticdog.__mro__)

stack = [] # we could just use a list as a stackstack.append(1)  # pushstack.append(2)print(stack.pop())  # pop

#include <stack> // we have to import the stack typestd::stack<int> stack;stack.push(1);  // pushstack.push(2);std::cout << stack.top() << std::endl;  // topstack.pop();  // pop

from collections import dequequeue = deque()queue.append(1)  # enqueuequeue.append(2)print(queue.popleft())  # dequeue

#include <queue>std::queue<int> queue;queue.push(1);  // enqueuequeue.push(2);std::cout << queue.front() << std::endl;  // frontqueue.pop();  // dequeue

map = {} # this is automatically creating a map (which is called a dictionary in python)map['key1'] = 'value1'map['key2'] = 'value2'print(map['key1'])

#include <map>std::map<std::string, std::string> map;map["key1"] = "value1";map["key2"] = "value2";std::cout << map["key1"] << std::endl;