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

# privado por convenção: _underscore_simples # "realmente privado": __underscore_duplo (name mangling) # público: sem underscore  from abc import abstractmethod class 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 true  class 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, abstractmethod  class 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 constructor pet constructor workinganimal constructor domesticdog constructor pet 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):     pass  dog = domesticdog() dog.make_sound() 

pet sound 

print(domesticdog.__mro__) 

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

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

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

#include <queue> std::queue<int> queue; queue.push(1);  // enqueue queue.push(2); std::cout << queue.front() << std::endl;  // front queue.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;