{"id":18272270,"url":"https://github.com/ryukinix/cpp-journey","last_synced_at":"2025-04-05T02:31:00.935Z","repository":{"id":72149050,"uuid":"96502265","full_name":"ryukinix/cpp-journey","owner":"ryukinix","description":"My personal notes/codes about the infernal adventure to learn C++ from HackerRank [pt-br]","archived":false,"fork":false,"pushed_at":"2017-07-27T19:19:25.000Z","size":75,"stargazers_count":9,"open_issues_count":0,"forks_count":0,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-03-20T20:36:52.331Z","etag":null,"topics":["cpp","hackerrank","solutions"],"latest_commit_sha":null,"homepage":"https://lerax.me/programming/cpp-journey","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/ryukinix.png","metadata":{"files":{"readme":"README.org","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2017-07-07T05:27:40.000Z","updated_at":"2022-06-15T10:11:26.000Z","dependencies_parsed_at":null,"dependency_job_id":"ab63219d-0788-4257-9812-35bcc2f73240","html_url":"https://github.com/ryukinix/cpp-journey","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ryukinix%2Fcpp-journey","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ryukinix%2Fcpp-journey/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ryukinix%2Fcpp-journey/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ryukinix%2Fcpp-journey/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/ryukinix","download_url":"https://codeload.github.com/ryukinix/cpp-journey/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247279357,"owners_count":20912868,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cpp","hackerrank","solutions"],"created_at":"2024-11-05T11:41:48.135Z","updated_at":"2025-04-05T02:31:00.891Z","avatar_url":"https://github.com/ryukinix.png","language":"C++","readme":"#+STARTUP: showall\n#+STARTUP: hidestars\n#+OPTIONS: H:3 num:nil tags:nil \\n:t ^:nil todo:nil tasks:done toc:nil timestamps:t\n#+TAGS: C++, Programming, HackerRank\n#+LAYOUT: post\n#+AUTHOR: Manoel Vilela\n#+DATE: 2017-07-26 Wed 14:48\n#+TITLE: C++ Journey\n#+DESCRIPTION: Uma jornada no mundo infernal de C++ através do HackerRank\n#+CATEGORIES: C++, Programming\n#+COMMENTS: true\n\n\n* Tabela de Conteúdos  :TOC_3:\n:PROPERTIES:\n:CUSTOM_ID: toc-org\n:END:\n- [[#descrição][Descrição]]\n- [[#hackerrank-c][HackerRank C++]]\n    - [[#the-type-string][The Type String]]\n    - [[#streams][Streams]]\n    - [[#attribute-parser][Attribute Parser]]\n  - [[#orientação-a-objetos][Orientação a Objetos]]\n    - [[#introdução][Introdução]]\n    - [[#structs][Structs]]\n    - [[#básico-de-classes][Básico de Classes]]\n    - [[#class-constructors][Class constructors]]\n    - [[#exceptions][Exceptions]]\n    - [[#polymorphism-and-abstract-base-classes][Polymorphism and Abstract Base Classes]]\n  - [[#inheritance][Inheritance]]\n    - [[#inheritance-introduction][Inheritance Introduction]]\n    - [[#rectangle-area][Rectangle Area]]\n    - [[#multi-level-inheritance][Multi Level Inheritance]]\n    - [[#accessing-inherited-functions][Accessing Inherited Functions]]\n    - [[#magic-spells][Magic Spells]]\n  - [[#stl---c-standard-library][STL - C++ Standard Library]]\n    - [[#vector-sort][Vector Sort]]\n    - [[#vector-erase][Vector-Erase]]\n    - [[#lower-bound][Lower Bound]]\n    - [[#sets][Sets]]\n    - [[#maps][Maps]]\n    - [[#print-pretty][Print Pretty]]\n    - [[#deque][Deque]]\n  - [[#in-progress-extra][IN-PROGRESS Extra]]\n    - [[#c-class-templates][C++ Class Templates]]\n    - [[#preprocessor-solution][Preprocessor Solution]]\n    - [[#operator-overloading][Operator Overloading]]\n    - [[#overload-operators][Overload Operators]]\n    - [[#attending-workshops][Attending Workshops]]\n    - [[#c-class-template-specialization][C++ Class Template Specialization]]\n    - [[#c-variadics][C++ Variadics]]\n    - [[#bit-array][Bit Array]]\n- [[#c-prime-checking][C++ prime checking]]\n- [[#estudos-de-caso][Estudos de caso]]\n  - [[#listas-de-inicialização-para-construtores][Listas de inicialização para construtores]]\n  - [[#separadores-de-escopo--e-][Separadores de escopo ~::~ e ~.~]]\n\n* DONE Descrição\n\nMinha jornada com C++ no HackerRank principalmente e outras coisas. Na maioria\ndas questões não uso todos os recursos de ~C++14~, mas às vezes sim. Assume-se,\npor via das dúvidas, que todos arquivos estão no padrão ~C++14~.\n\n* DONE HackerRank C++\n   CLOSED: [2017-07-26 qua 14:34]\n*** DONE The Type String\n    SCHEDULED: \u003c2017-07-05 qua\u003e\n    CLOSED: [2017-07-05 qua 16:04]\n    CLOCK: [2017-07-05 qua 14:31]--[2017-07-05 qua 14:47] =\u003e  0:16\n\nDiferentemente de C, C++ implementa um tipo string não somente como uma cadeia\nde caracteres, mas como um objeto. Possui métodos associados, como `string::length`.\nÉ bem útil e menos difícil de tratar que /strings/ em C, que são apenas vetores de caracteres.\n\n\n#+BEGIN_SRC C++\n// inicialização de string\nstring a = \"abc\";\n// tamanho\na.size()\n// concatenação\nstring b = \"def\"\nstring c = a + b; // \"abcdef\"\n\n#+END_SRC\n\nO primeiro exercício do HackerRank:\n\n#+BEGIN_SRC C++\n#include \u003ciostream\u003e\n#include \u003cstring\u003e\n#include \u003calgorithm\u003e\nusing namespace std;\n\nint main() {\n    string a,b;\n    cin \u003e\u003e a;\n    cin \u003e\u003e b;\n    cout \u003c\u003c a.size() \u003c\u003c \" \" \u003c\u003c b.size() \u003c\u003c endl;\n    cout \u003c\u003c a + b \u003c\u003c endl;\n    char temp = a[0];\n    a[0] = b[0];\n    b[0] = temp;\n    cout \u003c\u003c a \u003c\u003c \" \" \u003c\u003c b \u003c\u003c endl;\n\n    return 0;\n}\n\n#+END_SRC\n\n\nLidando com tamanho, concatenação e substituição de caracteres\nem ~strings~.\n\n*** DONE Streams\n    CLOSED: [2017-07-05 qua 16:20]\n    SCHEDULED: \u003c2017-07-05 qua\u003e\n    CLOCK: [2017-07-05 qua 15:01]--[2017-07-05 qua 16:09] =\u003e  1:08\n\nEsse tópico refere-se ao gerenciamento de /stream/ usando /strings/\npara C++. Muito interessante. O operador \u003c\u003c insere informação,\npor outro lado, o operador \u003e\u003e extrai informação.\n\n\nO método de inicialização da ~stringstream~ cria uma /stream/. O cabeçalho é ~\u003csstream\u003e~.\n[[https://github.com/ryukinix/cpp-journey/tree/master/Strings/strings-2.cpp][HackerRank-Problem-String]]\nO método ~sstream::eof~ verifica se a /stream/ está no fim. ~EOF~ = End Of File.\n\n*** DONE Attribute Parser\n    CLOSED: [2017-07-06 qui 06:49]\n    SCHEDULED: \u003c2017-07-05 qua\u003e\n    CLOCK: [2017-07-05 qua 16:09]--[2017-07-06 qui 06:32] =\u003e 14:23 (horas!)\n\nNessa atividade, a última de /strings/, vou precisar fazer um /parser/ de atributos\nem CancerPlusPlus (aka C++). Um pouco da descrição do site é dada no /block/ de código abaixo.\n\n#+BEGIN_SRC xml\nWe have defined our own markup language HRML. In HRML, each element consists of\na starting and ending tag, and there are attributes associated with each tag.\nOnly starting tags can have attributes. We can call an attribute by referencing\nthe tag, followed by a tilde, '~' and the name of the attribute.\nThe tags may also be nested.\n\nSample Input\n\n4 3\n\u003ctag1 value = \"HelloWorld\"\u003e\n\u003ctag2 name = \"Name1\"\u003e\n\u003c/tag2\u003e\n\u003c/tag1\u003e\ntag1.tag2~name\ntag1~name\ntag1~value\n\nSample Output\n\nName1\nNot Found!\nHelloWorld\n#+END_SRC\n\nA atividade está sendo desenvolvida no arquivo:\n[[https://github.com/ryukinix/cpp-journey/tree/master/Strings/strings-3-attribute-parser.cpp][Attribute Parser]]\n\nJá estou há várias horas resolvendo esse problema. Sinceramente é um pouco\ntrabalhoso. Agora é \u003c2017-07-06 qui 01:50\u003e. Já se passou mais de 8 horas...\nque inferno! Mas eu dormi um pouco antes também. Cassete! terminei agora depois\nde 14 horas! Uma completa desgraça!\n\nQUE INFERNO!!!!!! TERMINEI!!!!\n\nPrimeiramente interpretei o problema um tanto errado, pensando que a primeira\ntag seria a raíz da árvore. O que deu bastante problema para contornar.\nApós isso havia vários erros, como o não tratamento de espaços antes das chaves,\ncomo indentação. Isso não parece ter nenhum efeito durante a correção. Mas\nsó fui perceber todos os erros após conseguir o SUITE TESTCASE #4 de um\nrepositório do github. O problema central, depois de corrigir a modelagem errada,\nera em relação ao método de pesquisa.\n**\n** DONE Orientação a Objetos\n   CLOSED: [2017-07-09 dom 00:02]\n*** DONE Introdução\n   CLOSED: [2017-07-06 qui 20:57]\n   SCHEDULED: \u003c2017-07-05 qua\u003e\n   CLOCK: [2017-07-05 qua 14:00]--[2017-07-05 qua 14:29] =\u003e  0:29\n\nEstou fazendo alguns exercícios de C++ no HackerRank. Até agora não estou\ncom muitos problemas. Na verdade C++ não é tão difícil quanto eu pensei.\nDe fato, na verdade, eu nunca tinha parado pra olhar direito como era a\nlinguagem e só ficava de tretinha básica.\n\nOO em C++ parece ser divertido, apesar de ainda ter uma impressão /cancerígina/.\nNão é pra menos... /keywords/, ~friend~, ~public~, ~private~ e ~protected~?\nMas, enfim, acho que vou conseguir me acostumar. Quero terminar hoje ainda a\nintrodução, estou na última parte envolvendo OO, herança e variáveis estáticas.\n\nMétodo virtuais em C++ são usados para fazer polimorfismo dinâmicos em heranças.\n/Protected/ são membros acessíveis apenas pelas subclasses. /Private/ são\nacessíveis apenas pelos métodos da classe. /Public/ são publicos para todos.\n\nPor padrão, membros e métodos são privados em classes. Para fazer um membro ou\nmétodo público você deve o fazer explicitamente com a keyword ~public~ e o uso\nde dois pontos ~:~. É possível usar a /keyword/ ~friend~ para acessar atributos\nprivados de outra classe. Provavelmente eu não deveria\nestar falando desses tópicos avançados de OO na introdução (HAHA!). Mas\né bom que dá o gostinho de desgraça que C++ tem tanto de especial.\n#+BEGIN_SRC C++\nconst int NUMBER_OF_MARKS = 6;\n\nclass Person {\nprotected:\n    string name;\n    int age;\npublic:\n    virtual void putdata(void){};\n    virtual void getdata(void){};\n};\n\nclass Professor: public Person {\nprivate:\n    int publications;\n    int cur_id;\npublic:\n    static int count;\n    Professor(void){\n        cur_id = count + 1;\n        count += 1;\n    }\n    virtual void putdata(void) {\n        // The function putdata should print the name, age,\n        // publications and the cur_id of the professor.\n        cout \u003c\u003c name \u003c\u003c \" \";\n        cout \u003c\u003c age \u003c\u003c \" \";\n        cout \u003c\u003c publications \u003c\u003c \" \";\n        cout \u003c\u003c cur_id \u003c\u003c endl;\n    }\n\n    virtual void getdata(void) {\n        cin \u003e\u003e name;\n        cin \u003e\u003e age;\n        cin \u003e\u003e publications;\n    }\n};\n\nclass Student: public Person {\nprivate:\n    int marks[NUMBER_OF_MARKS];\n    int _sum_marks() {\n        int total = 0;\n        for (int i = 0; i \u003c NUMBER_OF_MARKS; i++) {\n            total += marks[i];\n        }\n        return total;\n    }\n    int cur_id;\npublic:\n    static int count;\n    Student(void) {\n        cur_id = count + 1;\n        count += 1;\n    }\n    virtual void putdata(void) {\n        // The function putdata should print the name, age,\n        // sum of the marks and the cur_id of the student.\n        cout \u003c\u003c name \u003c\u003c \" \";\n        cout \u003c\u003c age \u003c\u003c \" \";\n        cout \u003c\u003c _sum_marks() \u003c\u003c \" \";\n        cout \u003c\u003c cur_id \u003c\u003c endl;\n\n    }\n\n    virtual void getdata(void) {\n        cin \u003e\u003e name;\n        cin \u003e\u003e age;\n        for (int i = 0; i \u003c NUMBER_OF_MARKS; i++){\n            cin \u003e\u003e marks[i];\n        }\n\n    }\n\n};\n\nint Professor::count = 0;\nint Student::count = 0;\n\n#+END_SRC\n\nConstrutores podem ser definidos uma ou várias vezes.\nNo entanto, destrutores só podem ser definidos uma vez.\n\n*** DONE Structs\n   CLOSED: [2017-07-06 qui 06:58]\n   SCHEDULED: \u003c2017-07-06 qui\u003e\n   CLOCK: [2017-07-06 qui 06:51]--[2017-07-06 qui 06:57] =\u003e  0:06\n\nOs structs em C++ são semelhantes de C, no entanto eles são como classes\ncom membros e métodos públicos por padrão. Usualmente structs são usados apenas\npara agrupar membros de variáveis numa estrutura compartilhada, podendo assim,\ncriar estrutura de dados mais complexas.\n\n*** DONE Básico de Classes\n   CLOSED: [2017-07-06 qui 08:00]\n   SCHEDULED: \u003c2017-07-05 qua\u003e\n   CLOCK: [2017-07-06 qui 06:58]--[2017-07-06 qui 08:00] =\u003e  1:02\n\nPor padrão classes tem seus métodos e atributos privados, sendo reservado as\nkeywords para controle de acesso: ~protected~, ~private~ e ~public~.\nUma prática comum em C++ é deixar todos os atributos privados ou protegidos\n(case for uma classe base de herança), então criar /getters/ e /setters/ públicos.\n\nUm exemplo de código abaixo é dado:\n\n#+BEGIN_SRC C++\nclass Student {\nprivate:\n    string name;\n    int age;\npublic:\n    string get_mame() {\n        return name;\n    }\n\n    string get_age() {\n        return age;\n    }\n\n    void set_name(string new_name) {\n        name = new_name;\n    }\n\n    void set_age(int new_age) {\n        age = new_age;\n    }\n}\n\n#+END_SRC\n\n*** DONE Class constructors\n    CLOSED: [2017-07-06 qui 08:50]\n    SCHEDULED: \u003c2017-07-06 qui\u003e\n\nConstrutores são chamados na inicialização de uma classe. Podem possuir um ou mais,\ncom diferentes assinaturas.\nOs tipos de construtores são três:\n\n1. Construtor padrão\n2. Construtor parametrizado\n3. Construtor de cópia\n\nExemplo: [[https://github.com/ryukinix/cpp-journey/tree/master/Classes/constructor.cpp][ConstructorsExample.cpp]]\n\n*** DONE Exceptions\n   CLOSED: [2017-07-06 qui 20:42]\n   SCHEDULED: \u003c2017-07-06 qui\u003e\n\nC++ permite criar exceções personalizadas ao criar uma herança da classe\n~exception~. O método descritivo da exceção é ~const char* what(){}~.\nUma atividade simples foi feita em: [[https://github.com/ryukinix/cpp-journey/tree/master/Classes/exception.cpp][Exceptions.cpp]]\nBlocos ~try/catch~ são usados pra lidar com exceções que ocorreram.\n~throw Exception();~ é usado para sinalizar uma exceção.\n\nMinha próxima atividade no HackerRank é a respeito de um servidor para\ncapturar exceções customizadas.\n[[https://github.com/ryukinix/cpp-journey/tree/master/Classes/CustomExceptions.cpp][CustomExceptions.cpp]]\n\nTodas as exceções padrões tem como base classe ~std::exception~.\nUma maneira simples de capturar uma exceção e imprimi-la, é desta maneira:\n\n#+BEGIN_SRC C++\n#include \u003cexception\u003e // definição da classe base std::exception\n#include \u003cstdexcept\u003e // várias exceções padrões para ser usadas\ntry {\n    std::cout \u003c\u003c 1/0;\n} catch(std::exception const\u0026 e) {\n    std::cout \u003c\u003c \"Erro do capeta: \" \u003c\u003c e.what();\n} catch(...) {\n    // essa sessão captura qualquer exceção não esperada\n}\n#+END_SRC\n\nExceções definidas no cabeçalho \u003cstdexcept\u003e\n- ~bad_alloc~\n- ~bad_cast~\n- ~bad_exception~\n- ~bad_typeid~\n- ~logic_error~\n  - ~domain_error~\n  - ~invalid_argument~\n  - ~length_error~\n  - ~out_of_range~\n- ~runtime_error~\n  - ~range_error~\n  - ~overflow_error~\n  - ~underflow_error~\n*** DONE Polymorphism and Abstract Base Classes\n    CLOSED: [2017-07-08 sáb 05:23]\n    CLOCK: [2017-07-08 sáb 02:20]--[2017-07-08 sáb 05:21] =\u003e  3:01\n    CLOCK: [2017-07-06 qui 20:49]--[2017-07-07 sex 22:43] =\u003e 25:54\n\nComecei a fazer essa atividade agora às \u003c2017-07-06 qui 20:51\u003e.\nPolimorfismo é quando um método na herança é modificado. Em C++\nexistem as chamadas Classes Abstratas de Base, onde é permitido que elas\npossuam apenas métodos virtuais para futuramente, numa herança, realizar\npolimorfismo.\n\nEssa última atividade é bem /cabulosa/. O objetivo é implementar um sistema\nde /cache/ usando listas duplamente encadeadas e, além disso, fazer de tal maneira\nque use os conceitos referentes a polimorfismo numa classe chamada Cache.\n\nAs atividades a serem desenvolvidas aqui podem ser encontradas em:\n[[https://github.com/ryukinix/cpp-journey/tree/master/Classes/AbstractPolymorphism.cpp][AbstractPolymorphism.cpp]].\n\nDepois de um dia tentando ter um progresso com essa atividade, já consegui\nimplementar a funcionalidade básica do ~Cache~. No entanto, os testes com maiores\nentradas estão com problemas. De acordo com a execução do HackerRank, está\nocorrendo ~segfault~. Acredito que possa ser devido o não tratamento direto\nda desalocação dos objetos Nó durante a chamada de void ~pop_node();~ que\ndesaloca a cauda da lista. Contínuo essa atividade mais tarde.\n\nDe fato durante o ~pop_node()~; há um vazamento de memória. A referência do objeto\né perdida, mas no entanto o objeto em si não é removido. Foi realizado uma\nverificação manual na versão deste [[https://github.com/ryukinix/cpp-journey/tree/master/commit/bb6741d41c74cca1974bb41f3cd0f865a0d7be2c][commit]].\nA estratégia assumida é para gerenciar corretamente a memória durante as novas\nalocações.\n\nComo eu suspeitava, a função ~LRUCache::pop_node()~ que estava vazando memória.\nApós a adição das instruções pra desalocar tanto a cauda como também a entrada\ndesse nó no ~HashMap mp~, os testes do HackerRank passaram. Mas demorei demais pra\nfazer tudo. Quase 30 horas! Bem que no HackerRank comentava que era uma questão\ndifícil.\n\n** DONE Inheritance\n    CLOSED: [2017-07-09 dom 00:02] SCHEDULED: \u003c2017-07-08 sáb\u003e\n\nEste é um tópico especial envolvendo como funciona o conceito de herança\nem C++, todo mal da orientação objetos, como também é uma prática comum\nem muitos projetos que usam linguagens como C++.\n\nEstarei linkando nos próximos títulos os códigos-fontes de cada\nsolução das questões.\n\n*** DONE Inheritance Introduction\n     CLOSED: [2017-07-08 sáb 05:50] SCHEDULED: \u003c2017-07-08 sáb\u003e\n\nNessa atividade é pedido pra construir um método de descrição de uma sub-classe\nde ~Triangle~ chamada ~Isosceles~. A construção é bem direta e não é necessário\nmuita explicação. É tão estúpida que até pensei em não deixar o código fonte aqui.\nMas vamos lá... [[https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/TriangleInheritance.cpp][TriangleInheritance.cpp]]\n\n*** DONE Rectangle Area\n     CLOSED: [2017-07-08 sáb 06:22] SCHEDULED: \u003c2017-07-08 sáb\u003e\n     CLOCK: [2017-07-08 sáb 06:12]--[2017-07-08 sáb 06:22] =\u003e  0:10\n\nNesta atividade será feito um exercício para cálculo\nda área de um retângulo usando os conceitos de herança. Durante\na construção da solução foi possível perceber que era possível\nchamar métodos da classe base com mesmo nome, no caso ambos possuíam\no método ~void display~, mas a instância do objeto era ~RectangleArea~.\nPara acessar então, ~display~ de ~Rectangle~, foi necessário a seguinte\nsintaxe:\n\n#+BEGIN_SRC C++\nRectangleArea r_area;\nr_area.Rectangle::display();\n#+END_SRC\n\nA solução completa pode ser encontrada aqui:\n[[https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/RectangleArea.cpp][RectangleArea.cpp]]\n\n*** DONE Multi Level Inheritance\n     CLOSED: [2017-07-08 sáb 06:43] SCHEDULED: \u003c2017-07-08 sáb\u003e\n     CLOCK: [2017-07-08 sáb 06:35]--[2017-07-08 sáb 06:43] =\u003e  0:08\n     É possível fazer herança em mais de um nível. Um exemplo é dado\nno exercício para a construção de uma classe ~Equilateral~, que deriva\nde ~Isosceles~, que é derivado de ~Triangle~. Isso demonstra a interdependência\ndas propriedades que uma instância de ~Equilateral~ tem entre ~Isosceles~\ne ~Triangle~. O que é realmente verdade, já que um triângulo Equilátero\né obviamente também um Triângulo e é Isósceles.\n\nA atividade foi direta de ser completa e está descrita a seguir:\n[[https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/IsoscelesEquilateral.cpp][IsoscelesEquilateral.cpp]]\n\n*** DONE Accessing Inherited Functions\n     CLOSED: [2017-07-08 sáb 07:21] SCHEDULED: \u003c2017-07-08 sáb\u003e\n     CLOCK: [2017-07-08 sáb 06:48]--[2017-07-08 sáb 07:21] =\u003e  0:33\n     Como comentada na questão /Rectangle Area/, é possível acessar\nfunções/métodos da classe base que foi herdada. Nessa atividade\nirei descrever brevemente a implementação do exercício proposto no\nHackerRank.\n\nA atividade é descrita em: [[https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/AcessingInheritedFunctions.cpp][AcessingInheritedFunctions.cpp]]\n\nA questão pede para se chegar a um número de entrada usando apenas as classes\nde base A, B e C.\n*** DONE Magic Spells\n     CLOSED: [2017-07-09 dom 00:02] SCHEDULED: \u003c2017-07-08 sáb\u003e\n     CLOCK: [2017-07-08 sáb 21:57]--[2017-07-09 dom 00:01] =\u003e  2:04\n     CLOCK: [2017-07-08 sáb 07:31]--[2017-07-08 sáb 13:46] =\u003e  6:15\n\nLá vem questão *HARD* de novo diretamente do inferno no HackerRank. Essa questão\nenvolve o uso de herança e ~dynamic_cast~, que é basicamente o que tentei fazer\numa vez em C e só me fudi -- implementar uma variável de tipo dinâmico, acabei terminando com um ~union~ e ~enum~.\nParece que C++ implementa algo parecido do que eu desejei pra lidar com esse tipo de problema.\n\nNesse caso ~dynamic_cast~ é usado para modelar uma instância compatível com outro tipo\nou classe. Se um ~nullptr~ é retornado, significa que os tipos não são compatíveis.\nNessa questão isso é usado para saber que tipo de que classe derivada de ~Spell~\nfoi instanciada. A sintaxe é dada por ~dynamic_cast\u003cType*\u003e(instance*)~. Muito\nsemelhante ao /cast/ estático de C, embora há também ~static_cast\u003cType\u003e(instance)~.\n\nEstou tendo alguns problemas para construir um algoritmo do tipo LCS.\nIsto é: Longest Common Substring. Quando o spell é da classe Base, out seja,\num tipo de magia desconhecida, é necessário que o mago olhe no catálogo de magias\ne compare o nome da magia com o que foi recebido. Dada as duas strings, a recebida\ne a do catálogo, devo retornar o tamanho da substring maior.\n\nOu seja, é dado o exemplo que para ~AquaVitae~ e ~AruTaVae~ a maior substring é\n~AuaVae~. Não tenho tanta certeza se isso está correto, mas achei um código exemplo\nem C++ pra testar. Está linkado em [[https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/LongestCommonSubstring.cpp][LongestCommonSubstring.cpp]]\n\nMinha desconfiança sobre isso é da natureza que esse exemplo não retorna\nexatamente a maior substring e sim a maior cadeia possível em sequência, se\nnecessário, removendo o que tiver no meio entre elas.\n\nVou dar uma pausa aqui nessa atividade agora às \u003c2017-07-08 sáb 13:48\u003e.\nDepois vou tentar voltar mais tarde. A parte inicial da atividade está feita\nem: [[https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/MagicSpells.cpp][MagicSpells.cpp]]\n\nEstou de volta nessa atividade dos demônios. Realmente a detecção das classes\nfilhas ao usar dynamic cast estão funcionando bem. Na verdade dynamic cast é\num pouco diferente do que pensei, você não pode fazer conversão de tipos\narbitrários, mas sim àqueles que são possíveis. Como no caso de um instância\nPai para uma classe Filha (derivada, herdada).\n\nNo entanto estou com problemas demais em relação a desgraça do algoritmo\npara de cálculo de maior substring recorrente entre duas strings, pois esse\nproblema de fato não é o Longest Common Substring. Vou precisar fazer um algoritmo\npersonalizado pra isso. Talvez eu devesse começar fazendo em Python pra facilitar\na lógica e depois passar pra Câncer++.\n\nAgora tudo faz sentido, eu estava tentando resolver um problema com a solução\npara outro tipo de problema. Esse problema na verdade tem outro nome. Apesar\nde semelhante ao Longest Common Substring, este se chama Longest Common\nSubsequence. Uma solução em Python transcrita de um pseudo código pode ser vista\nabaixo:\n\n#+BEGIN_SRC python\ndef LCSLength(X, Y):\n    from pprint import pprint\n    m, n = len(X) + 1, len(Y) + 1\n    C = [[0 for _ in range(n)] for _ in range(m)]\n    for i in range(1, m):\n        for j in range(1, n):\n            if X[i-1] == Y[j-1]:\n                C[i][j] = C[i-1][j-1] + 1\n            else:\n                C[i][j] = max(C[i][j-1], C[i-1][j])\n    pprint(C)\n    return C[n-1][m-1]\n#+END_SRC\n\nVou tentar agora codificar isso em C++. Finalizado. Que desgraça hein.\nA parte mais difícil desse problema não era exatamente lidar com o dynamic_cast\ne detectar que classe filha estão sendo referenciadas. Na verdade esse problema\naí do Longest Common Subsequence é bem mais difícil. Engraçado porque esse tópico\né sobre herança, o que esse problema NP-Hard é simplemente sem relação!\n\n** DONE STL - C++ Standard Library\n   CLOSED: [2017-07-26 qua 14:34]\n*** DONE Vector Sort\n   CLOSED: [2017-07-06 qui 20:44]\n   CLOCK: [2017-07-06 qui 10:29]--[2017-07-06 qui 10:36] =\u003e  0:07\nA Standard Library de C++ vem com muitos bultins. Um dos métodos\nda biblioteca é ~std::sort(vector::begin, vector::end)~.\n\n#+CAPTION: Ordenar n números\n#+BEGIN_SRC C++\n#include \u003ccmath\u003e\n#include \u003ccstdio\u003e\n#include \u003cvector\u003e\n#include \u003ciostream\u003e\n#include \u003calgorithm\u003e\nusing namespace std;\n\n\nint main() {\n    int n, x;\n    cin \u003e\u003e n;\n    vector\u003cint\u003e v;\n    for(int i = 0; i \u003c n; i++) {\n        cin \u003e\u003e x;\n        v.push_back(x);\n    }\n    sort(v.begin(), v.end());\n    for(int x :v) {\n        cout \u003c\u003c x \u003c\u003c \" \";\n    }\n    return 0;\n}\n\n#+END_SRC\n*** DONE Vector-Erase\n    CLOSED: [2017-07-09 dom 06:28] SCHEDULED: \u003c2017-07-09 dom\u003e\n    CLOCK: [2017-07-09 dom 06:25]--[2017-07-09 dom 06:28] =\u003e  0:03\n\nA STL definida em ~\u003calgorithm\u003e~ e ~\u003cvector\u003e~ define alguns métodos\núteis, como por exemplo o método ~vector::erase~ para remover elementos\nseja de apenas uma localização ou um intervalo.\n\nO seguinte código foi feito para o exercício proposto do hackerrank:\n#+BEGIN_SRC C++\n#include \u003ccmath\u003e\n#include \u003ccstdio\u003e\n#include \u003cvector\u003e\n#include \u003ciostream\u003e\n#include \u003calgorithm\u003e\nusing namespace std;\n\n\nint main() {\n    vector\u003clong\u003e v;\n    int n,x,a,b;\n    cin \u003e\u003e n;\n    for (int i = 0; i \u003c n; i++) {\n        cin \u003e\u003e x;\n        v.push_back(x);\n    }\n\n    cin \u003e\u003e x;\n    v.erase(v.begin()+x-1);\n    cin \u003e\u003e a;\n    cin \u003e\u003e b;\n    v.erase(v.begin()+a-1, v.begin()+b-1);\n    cout \u003c\u003c v.size() \u003c\u003c endl;\n\n    for (int x : v) {\n        cout \u003c\u003c x \u003c\u003c \" \";\n    }\n    return 0;\n}\n#+END_SRC\n\nOu seja, há duas definições para vector::erase.\n- ~vector::erase(const iterator n);~\n- ~vector::erase(const iterator n, const iterator m);~\n\nO const iterator pode ser obtido a partido dos métodos:\n~vector::begin~ e ~vector::end~.\n\n*** DONE Lower Bound\n    CLOSED: [2017-07-09 dom 08:02] SCHEDULED: \u003c2017-07-09 dom\u003e\n    CLOCK: [2017-07-09 dom 06:29]--[2017-07-09 dom 08:02] =\u003e  1:33\n\nEm C++ a STL provém funções úteis para iterações e comparações.\nUm delas são os métodos ~std::lower_bound~ e ~std::upper_bound~.\nAmbas funções recebem três parâmetros, os dois primeiros sendo\no iterador inicial então o iterador final (~vector::begin~ \u0026 ~vector::end~).\nO terceiro elemento é um objeto de comparação que implementa operator\u003c\npara ~std::lower_bound~ e ~std::upper_bound~.\n\nO método ~std::lower_bound~ retorna o número menor que a comparação que esteja\nmais próximo desse número esquerda. ~std::upper_bound~ retorna o maior número que esteja\nmais próximo desse pela direita. Isso, é claro supondo um vetor ordenado.\n\nPode-se encontrar uma solução para este problema no arquivo:\n[[https://github.com/ryukinix/cpp-journey/tree/master/STL/LowerBound.cpp][LowerBound.cpp]]\n\n*** DONE Sets\n    CLOSED: [2017-07-09 dom 08:33] SCHEDULED: \u003c2017-07-09 dom\u003e\n    CLOCK: [2017-07-09 dom 08:12]--[2017-07-09 dom 08:33] =\u003e  0:21\n\nEssa próxima atividade se refere a implementação de conjuntos na biblioteca\npadrão de C++. Definida no cabeçalho ~#include \u003cset\u003e~ os métodos conhecidos para\no tipo set, são:\n\n- ~std::set\u003cint\u003e s~;\n- ~s.length()~; (tamanho do conjunto)\n- ~s.erase(int n)~; (apagar um elemento)\n- ~s.insert(int n)~; (inserir um elemento)\n- ~set\u003cint\u003e::iterator it = s.find(int n);~ (procura um elemento, devolve um iterator)\n\nSe o elemento não é encontrado ~it == s.end();~\n\nUm problema para explorar essas operações é proposto no HackerRank,\nonde uma solução pode ser encontrada aqui: [[https://github.com/ryukinix/cpp-journey/tree/master/STL/Set.cpp][Set.cpp]]\n\n*** DONE Maps\n    CLOSED: [2017-07-09 dom 09:01] SCHEDULED: \u003c2017-07-09 dom\u003e\n    CLOCK: [2017-07-09 dom 08:43]--[2017-07-09 dom 09:01] =\u003e  0:18\n\nHashMaps e Maps são implementados em C++ pela STL, Standard Library. Também conhecidos\nem outras linguagens como dicionários (python), HashMaps armazenam unidades de\nde pares ~\u003cchave, valor\u003e~ na qual a existência para uma dada chave é única.\n\nVale ressaltar, explicitamente, que HashMaps em C++ são conhecidos como ~unordered_map~\ne Maps são implementados com ~red black trees~, árvores de busca do tipo balanceada.\nA principal diferença é que ~unordered_map~ possui acesso/inserção com complexidade\nO(1) se não houver colisão (se houver, no pior caso é O(n)). E ~map~ é *SEMPRE* O(log(n)).\n\nExistem alguns métodos úteis implementados para HashMaps e Maps. O tipo ~map~ é definido\nem ~\u003cmap\u003e~ e segue que:\n\n#+BEGIN_SRC C++\n#include \u003cmap\u003e\n\nstd::map\u003cint, string\u003e m; // declaração\nm.insert(std::make_pair(1, \"banana\")); // inserção\nm[1] = \"banana\"; // açucar sintático para inserção\nm.erase(\"banana\"); //remover elemento\nm.find(key); // m\u003cint,string\u003e::iterator\n// se um elemento não é encontrado então m.find(key) == m.end();\nm[1]; // \"banana\n#+END_SRC\n\nUm problema é proposto no HackerRank para explorar essas operações.\nA implementação está feita no arquivo [[https://github.com/ryukinix/cpp-journey/tree/master/STL/HashMap.cpp][HashMap.cpp]].\n\nEdit: Pensei inicialmente que ~map~ de C++ eram HashMaps, por isso algumas trocas aqui.\n\n*** DONE Print Pretty\n    CLOSED: [2017-07-25 ter 17:50] SCHEDULED: \u003c2017-07-24 Mon\u003e\n    CLOCK: [2017-07-24 Mon 19:09]--[2017-07-25 ter 17:52] =\u003e 22:43\n\nPreciso fazer essa atividade. Irei começar daqui a pouco. Basicamente\na atividade é em relação a imprimir diferente tipos de dados com uma determinada\ncaracterística. Por exemplos, notação científica para decimais. Números\ndecimais prefixado e também números inteiros com caracteres prefixado.\nParece que STL já implementa isso em algum lugar.\n\nA atividade será desenvolvida em: [[https://github.com/ryukinix/cpp-journey/tree/master/STL/PrettyPrint.cpp][PrettyPrint.cpp]]\n\nMaiores anotações virão a seguir.\n\nBem... trabalhar com formatação de IO em C++ é no mínimo doloroso.\nNa verdade eu achei um completo inferno, mas vou tentar descrever algumas coisas\nque entendi.\n\nNo cabeçalho ~\u003ciomanip\u003e~ é definido várias entradas para trabalhar com formatação\nde stringstreams, ou necessariamente IO.\n\nEntre diretrizes pra trabalhar com números de qualquer tipo tem-se:\n\n- ~showbase~ -- mostra a base do número, como hex e octal\n- ~noshowbase~ -- desativa a opção acima\n- ~showpos~ -- todos números são definidos com sinal prefixado +/-\n- ~noshowpos~ -- desativa a opção acima\n- ~setbase~ -- define qual é a base no parsing, por exemplo 16 -\u003e hexadecimal\n- ~uppercase~ -- base e outros caracteres são usados em uppercase\n- ~nouppercase~ -- o contrário da opção acima\n\nPara setbase temos atalhos predefinidos como ~hex~, ~oct~ e ~dec~.\n\nPara preenchimento de string, largura máxima e alinhamento temos:\n\n- ~left~ -- alinha pela esquerda\n- ~right~ -- alinha pela direita\n- ~internal~ -- aplica a formação no número em si\n- ~setw~ -- define largura máxima\n- ~setfill~ -- recebe um caracter e preenche de acordo com a largura máxima esperada\n\nPara processamento de números flutuantes temos:\n\n- ~setprecision~ -- precisão em casas decimais\n- ~fixed~ -- notação prefixa =\u003e 10.001\n- ~scientific~ -- notação científica-\u003e 3.30303E+03\n- ~default~ -- notação padrão\n\nTambém tem hexfloat, mas isso é muito obscuro e não vou cobrir.\n\nPara fazer uma definição global de formação podemos usar ~setiosflags~ e ~resetiosflags~.\n\n~setiosflags~ recebe uma das ~flags~ acima não-parametrizada e define globalmente.\nComo o argumento esperado é uma ~bitmask~, é possível fazer qualquer operação de ~bitwise~.\n\nPor exemplo:\n#+BEGIN_SRC C++\n#include \u003ciostream\u003e\n#include \u003ciomanip\u003e\n\nint main()\n{\n    std::cout \u003c\u003c  std::resetiosflags(std::ios_base::dec)\n              \u003c\u003c  std::setiosflags(  std::ios_base::hex\n                                   | std::ios_base::uppercase\n                                   | std::ios_base::showbase) \u003c\u003c 42 \u003c\u003c '\\n';\n}\n\n// Output:\n// 0X2A\n\n#+END_SRC\n\n\nIsso é o básico. Mais informações estão [[http://en.cppreference.com/w/cpp/io/manip][aqui]].\n\n*** DONE Deque\n    CLOSED: [2017-07-26 qua 14:27] SCHEDULED: \u003c2017-07-25 ter\u003e\n    CLOCK: [2017-07-25 ter 21:27]--[2017-07-26 qua 14:27] =\u003e 17:00\n\nBem, esse problema refere-se ao uso do container Deque da STL.\nÉ dado um array, o seu tamanho e um índice K. O problema deseja saber\nquais são os valores máximos para cada subarray contínuo divididos em K.\n\nExemplo: [9,2,3,5,8], k=3\n\n[9,2,3] =\u003e 9\n[2,3,5] =\u003e 5\n[3,5,8] =\u003e 8\n\nUma aproximação ingênua nos levaria a fazer um algoritmo O(nk). Mas,\npercebendo que é somente necessário n comparações, com o auxílio de um deque\né possível armazenar os índices úteis dos valores para cada sub-array.\nComplexidade de Espaço: O(k).\n\nA idéia principal é criar um deque ordenado de maior valor ao menor, inserindo\nos índices do array. Quando terminar o subarray, imprimir a cabeça do deque\ne remover se ele não pertencer ao próximo array. Lembre-se que para cada sub-array,\nos indices x \u003c= (i - k) não pertencem mais ao sub-array.\n\nUma aproximação ótima pode ser descrita nesta implementação: [[https://github.com/ryukinix/cpp-journey/tree/master/STL/Deque.cpp][Deque.cpp]]\n\n** IN-PROGRESS Extra\n   DEADLINE: \u003c2017-07-31 seg\u003e\n*** DONE C++ Class Templates\n    CLOSED: [2017-07-27 Thu 04:58]\n    CLOCK: [2017-07-27 qui 03:02]--[2017-07-27 qui 16:05] =\u003e 13:03\n\n/Templates/ são usados para realizar meta-programação em C++. É uma forma muito\nmais poderosa e flexível que os conhecidos, macabros e perigosos macros\natravés do uso de preprocessador de C/C++. Uma simples\nquestão no HackerRank é feita para a introdução desse conceito.\n\n\nÉ solicitado para fazer um template ~AddElements~ que possua as seguintes características:\n\n- possa somar ~float~ e ~int~ com o método ~AddElements::add~\n- possa concatenar ~string~ com o método ~AddElements::concatenate~\n\n#+BEGIN_SRC C++\n/*Write the class AddElements here*/\ntemplate\u003cclass T\u003e // define uma classe parametrizada\nclass AddElements {\n    T element; // elemento com tipo a ser definido\n    public:\n    AddElements(T arg): element(arg){}; // inicialização\n    T add(T \u0026num) {\n        return element + num; // soma\n    }\n\n    T concatenate(T \u0026s) {\n        return add(s); // concatenação\n    }\n};\n#+END_SRC\n\nDessa maneira é possível fazer as seguintes instâncias com tipos paramétricos:\n\n#+BEGIN_SRC C++\nAddElements\u003cstring\u003e string_adder(\"salada\");\nAddElements\u003cint\u003e int_adder(10);\nAddElements\u003cfloat\u003e float_adder(0.5);\n\ncout \u003c\u003c string_adder.concatenate(\" verde\") \u003c\u003c endl;\ncout \u003c\u003c int_adder.add(5) \u003c\u003c endl;\ncout \u003c\u003c float_adder.add(0.5) \u003c\u003c endl;\n\n// OUTPUT:\n// salada verde\n// 15\n// 1.0\n#+END_SRC\n\nGeralmente containers em C++ são implementados usando Templates por conta da\nparametrização de tipos para uma mesma classe. Como um vector de ints, floats,\nset e qualquer tipo. Dessa maneira é possível criar uma classe com alta abstração\npara tratar muitos tipos diferentes. Um recurso muito poderoso de C++ se bem usado.\n\n\nAlém da keyword ~class~ como tipo de ~T~ é possível usar ~typename~ também. As\nduas keywords possuem diferentes significados em casos separados, como ~typename~\nser usado em tipos dependentes e ser recomendado usar ~class~ para classes aninhadas.\n\nO exemplo completo, como atividade do HackerRank, pode ser encontrado aqui:\n[[file:Extra/ClassTemplates.cpp][ClassTemplates.cpp]]\n\n*** DONE Preprocessor Solution\n    CLOSED: [2017-07-27 qui 16:05]\n    CLOCK: [2017-07-27 qui 15:05]--[2017-07-27 qui 16:05] =\u003e  1:00\n\nAssim como em C, C++ possui também diretrizes de processamento.\nTodas as diretrizes de preprocessamento ocorrem antes da geração de código\nobjeto, compilação e /linking/. Como sempre, essas diretrizes começam\ncom o símbolo /hash/ (#) prefixado.\n\nUm simples exemplo é dado a seguir:\n#+BEGIN_SRC C++\n#define INF 10000000\nif(val == INF) {\n    // Faça alguma coisa\n}\n\n// Depois do preprocessamento ter trocado as diretrizes, o código será\nif(val == 10000000) { //Aqui INF é trocado pelo valor do qual é definido.\n    //Do something\n}\n#+END_SRC\n\nIsso é chamado de ~macro~. ~#define~ define um macro.\n\nÉ possível também definir macros paramétricos.\n\n#+BEGIN_SRC C++\n#define add(a, b) a + b\nint x = add(a, b);\n\n// A segunda instrução após o preprocessamento ter aplicado as diretrizes será:\nint x = a + b;\n#+END_SRC\n\nÀs vezes macros podem ser interessantes em lugar de funções simples pelo custo\nda chamada de função, onde é feito muitas vezes cópia dos argumentos e alocados\nna pilha. Por outro lado, macros complicados muitas vezes são desencorajados\npela natureza difícil de fazer depuração de código.\n\nMais informações úteis podem ser encontrados [[http://en.cppreference.com/w/cpp/preprocessor][aqui]].\n\nEm uma breve história, supostamente estou ensinando crianças a programar\nem C++ (sim, crianças... coitadas). Então no final da noite vejo um\ncódigo promissor, mas infelizmente ele não compila. Para não desencorajar\nos pimpolhos, devo fazê-lo funcionar apenas escrevendo macros.\n\nEsta atividade é proposta no HackerRank e está escrita em [[file:Extra/PreprocessorSolution.cpp][PreprocessorSolution.cpp]].\n\n*** TODO Operator Overloading\n    SCHEDULED: \u003c2017-07-28 sex\u003e\n*** TODO Overload Operators\n    SCHEDULED: \u003c2017-07-28 sex\u003e\n*** TODO Attending Workshops\n    SCHEDULED: \u003c2017-07-29 sáb\u003e\n*** TODO C++ Class Template Specialization\n    SCHEDULED: \u003c2017-07-29 sáb\u003e\n*** TODO C++ Variadics\n    SCHEDULED: \u003c2017-07-30 dom\u003e\n*** TODO Bit Array\n    SCHEDULED: \u003c2017-07-30 dom\u003e\n\n* DONE C++ prime checking\n  CLOSED: [2017-07-05 qua 15:08]\n  SCHEDULED: \u003c2017-07-05 qua\u003e\n  CLOCK: [2017-07-05 qua 14:29]--[2017-07-05 qua 14:30] =\u003e  0:01\nUsei as bibliotecas:\n#+BEGIN_SRC C++\n#include \u003ciostream\u003e\n#include \u003ccstdlib\u003e\n#include \u003ccmath\u003e\n#+END_SRC\nEm iostream usei apenas cout. cstdlib precisei para a função atoi.\ncmath para sqrt.\nA linha de comando para compilação foi:\n~g++ source.cpp -o primep -lm~\n\nO arquivo pode ser encontrado em: [[https://github.com/ryukinix/cpp-journey/tree/master/Intro/primep.cpp][Prime Checking]]\n* DONE Estudos de caso\n  CLOSED: [2017-07-09 dom 06:48]\n** DONE Listas de inicialização para construtores\n   CLOSED: [2017-07-08 sáb 06:03] SCHEDULED: \u003c2017-07-07 sex\u003e\n   CLOCK: [2017-07-08 sáb 05:52]--[2017-07-08 sáb 06:03] =\u003e  0:11\nListas de inicialização é um tipo de sintaxe para escrever\nbrevemente construtores de classes, geralmente para inicializar valores.\nA sintaxe é usada como a seguir:\n\n#+BEGIN_SRC C++\nstruct Node {\n   int value;\n   Node* next;\n   Node(int v = 0, Node* ptr): value(v), next(ptr){};\n}\n#+END_SRC\n\nDessa maneira, é possível construir de maneiras muito simplórias construtores\nque apenas relacionam entradas de função para atributos de um objeto.\n\nVale lembrar que a ordem de inicialização deve estar de acordo com a declaração\ndos membros. De acordo com um membro do StackOverflow, em [[https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order][Constructor initialization-list evaluation order]],\nfoi dito que:\n\n\"The reason for which they are constructed in the member declaration order\nand not in the order in the constructor is that one may have several\nconstructors, but there is only one destructor.\nAnd the destructor destroy the members in the reserse order of construction.\n– AProgrammer\"\n\nOu seja, por conta de dependência entre os possíveis valores, a dependência\né que o destruidor destrói os membros de um objeto na ordem inversa de\nconstrução, logo, a ordem importa e deve ser mantida.\n\n** DONE Separadores de escopo ~::~ e ~.~\n   CLOSED: [2017-07-08 sáb 06:06] SCHEDULED: \u003c2017-07-07 sex\u003e\n   CLOCK: [2017-07-08 sáb 06:00]--[2017-07-08 sáb 06:06] =\u003e  0:06\n   O operador ~::~ é usado como separador de escopo e acessar\nmétodos/atributos estáticos. Por outro lado, ~.~ é usado apenas para\nacessar métodos/atributos de uma classe/struct que tenha instância. Além disso,\no operador ~-\u003e~ é usado no lugar de ~.~ quando o objeto é um ponteiro.\nOu seja, na verdade, ~(*a).b~ \u003c=\u003e ~a-\u003eb~. Ou seja, ~-\u003e~ é apenas uma açúcar\nsintático.\n\nNo StackOverflow, novamente, é possível ver uma resposta semelhante onde é\ncitado o que foi dito acima.\n[[https://stackoverflow.com/questions/2896286/whats-the-difference-between-dot-operator-and-scope-resolution-operator][What's the difference between dot operator and scope resolution operator?]]\n\n#  LocalWords:  iostream cstdlib cout cmath sqrt cpp primep lm public\n#  LocalWords:  Structs keywords protected private protecteds getters\n#  LocalWords:  setters structs class string return get void set int\n#  LocalWords:  Standard Library IN-PROGRESS Polymorphism Abstract\n#  LocalWords:  and Exceptions constructors new Student Type The\n#  LocalWords:  namespace\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fryukinix%2Fcpp-journey","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fryukinix%2Fcpp-journey","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fryukinix%2Fcpp-journey/lists"}