🎚️ Switch to the standard library style for C++.

Switching away from the "Python" style.

Author: rentruewang

cpp/calculator/CMakeLists.txt

@@ -3,9 +3,5 @@ project(Calculator)
 
 set(CMAKE_CXX_STANDARD 20)
 
-find_package(fmt CONFIG REQUIRED)
-
 file(GLOB FILES "*.cpp")
 add_executable(Calculator ${FILES})
-
-target_link_libraries(Calculator PRIVATE fmt::fmt)

cpp/calculator/calculator.cpp

@@ -2,81 +2,84 @@
 
 #include "calculator.hpp"
 
-#include <fmt/core.h>
+#include <string>
 
 using namespace std;
 
-shared_ptr<Expr> Expr::operator+(const shared_ptr<Expr>& other) const {
-    return make_shared<Eval>(shared_from_this(), other, "+",
-                             [](int a, int b) { return a + b; });
+shared_ptr<expression> expression::operator+(
+    const shared_ptr<expression>& other) const {
+    return make_shared<evaluation>(shared_from_this(), other, "+",
+                                   [](int a, int b) { return a + b; });
 }
 
-shared_ptr<Expr> Expr::operator-(const shared_ptr<Expr>& other) const {
-    return make_shared<Eval>(shared_from_this(), other, "-",
-                             [](int a, int b) { return a - b; });
+shared_ptr<expression> expression::operator-(
+    const shared_ptr<expression>& other) const {
+    return make_shared<evaluation>(shared_from_this(), other, "-",
+                                   [](int a, int b) { return a - b; });
 }
 
-shared_ptr<Expr> Expr::operator*(const shared_ptr<Expr>& other) const {
-    return make_shared<Eval>(shared_from_this(), other, "*",
-                             [](int a, int b) { return a * b; });
+shared_ptr<expression> expression::operator*(
+    const shared_ptr<expression>& other) const {
+    return make_shared<evaluation>(shared_from_this(), other, "*",
+                                   [](int a, int b) { return a * b; });
 }
 
-shared_ptr<Expr> Expr::operator/(const shared_ptr<Expr>& other) const {
-    return make_shared<Eval>(shared_from_this(), other, "/",
-                             [](int a, int b) { return a / b; });
+shared_ptr<expression> expression::operator/(
+    const shared_ptr<expression>& other) const {
+    return make_shared<evaluation>(shared_from_this(), other, "/",
+                                   [](int a, int b) { return a / b; });
 }
 
-Expr::~Expr() {}
+expression::~expression() {}
 
-Lit::Lit(int data) : data_(data) {}
+literal::literal(int data) : data_(data) {}
 
-shared_ptr<const Expr> Lit::simplify() const {
+shared_ptr<const expression> literal::simplify() const {
     return shared_from_this();
 }
 
-string Lit::to_string() const {
-    return fmt::format("{}", data_);
+literal::operator string() const {
+    return to_string(data_);
 }
 
-int Lit::data() const {
+int literal::data() const {
     return data_;
 }
 
-Lit::~Lit() {}
+literal::~literal() {}
 
-Var::Var(string data) : data_(data) {}
+variable::variable(string data) : data_(data) {}
 
-shared_ptr<const Expr> Var::simplify() const {
+shared_ptr<const expression> variable::simplify() const {
     return shared_from_this();
 }
 
-string Var::to_string() const {
+variable::operator string() const {
     return data_;
 }
 
-Var::~Var() {}
+variable::~variable() {}
 
-Eval::Eval(shared_ptr<const Expr> left,
-           shared_ptr<const Expr> right,
-           string token,
-           function<int(int, int)> func)
+evaluation::evaluation(shared_ptr<const expression> left,
+                       shared_ptr<const expression> right,
+                       string token,
+                       function<int(int, int)> func)
     : left_(left), right_(right), token_(token), func_(func) {}
 
-shared_ptr<const Expr> Eval::simplify() const {
-    auto lp = dynamic_pointer_cast<const Lit>(left_->simplify());
-    auto rp = dynamic_pointer_cast<const Lit>(right_->simplify());
+shared_ptr<const expression> evaluation::simplify() const {
+    auto lp = dynamic_pointer_cast<const literal>(left_->simplify());
+    auto rp = dynamic_pointer_cast<const literal>(right_->simplify());
 
     // Do nothing because no simplification is needed.
     if (lp == nullptr || rp == nullptr) {
         return shared_from_this();
     }
 
-    return make_shared<Lit>(func_(lp->data(), rp->data()));
+    return make_shared<literal>(func_(lp->data(), rp->data()));
 }
 
-string Eval::to_string() const {
-    return fmt::format("({} {} {})", left_->to_string(), token_,
-                       right_->to_string());
+evaluation::operator string() const {
+    return string(*left_) + " " + token_ + " " + string(*right_);
 }
 
-Eval::~Eval() {}
+evaluation::~evaluation() {}

cpp/calculator/calculator.hpp

@@ -9,63 +9,63 @@
 using namespace std;
 
 /// API: Lit, Var create two pointer to expressions.
-/// that has simplify(), to_string(), Add, Sub, Mul as methods.
+/// that has simplify(), operator string(), Add, Sub, Mul as methods.
 
-class Expr : public enable_shared_from_this<Expr> {
+class expression : public enable_shared_from_this<expression> {
    public:
-    shared_ptr<Expr> operator+(const shared_ptr<Expr>& other) const;
-    shared_ptr<Expr> operator-(const shared_ptr<Expr>& other) const;
-    shared_ptr<Expr> operator*(const shared_ptr<Expr>& other) const;
-    shared_ptr<Expr> operator/(const shared_ptr<Expr>& other) const;
+    shared_ptr<expression> operator+(const shared_ptr<expression>& other) const;
+    shared_ptr<expression> operator-(const shared_ptr<expression>& other) const;
+    shared_ptr<expression> operator*(const shared_ptr<expression>& other) const;
+    shared_ptr<expression> operator/(const shared_ptr<expression>& other) const;
 
-    virtual shared_ptr<const Expr> simplify() const = 0;
-    virtual string to_string() const = 0;
+    virtual shared_ptr<const expression> simplify() const = 0;
+    virtual operator string() const = 0;
 
-    virtual ~Expr();
+    virtual ~expression();
 };
 
-class Lit : public Expr {
+class literal : public expression {
    public:
-    Lit(int data);
+    literal(int data);
 
-    string to_string() const override;
-    shared_ptr<const Expr> simplify() const override;
+    operator string() const override;
+    shared_ptr<const expression> simplify() const override;
 
     int data() const;
 
-    ~Lit() override;
+    ~literal() override;
 
    private:
     int data_;
 };
 
-class Var : public Expr {
+class variable : public expression {
    public:
-    Var(string data);
+    variable(string data);
 
-    string to_string() const override;
-    shared_ptr<const Expr> simplify() const override;
+    operator string() const override;
+    shared_ptr<const expression> simplify() const override;
 
-    ~Var() override;
+    ~variable() override;
 
    private:
     string data_;
 };
 
-class Eval : public Expr {
+class evaluation : public expression {
    public:
-    Eval(shared_ptr<const Expr> left,
-         shared_ptr<const Expr> right,
-         string token,
-         function<int(int, int)> func);
-    ~Eval() override;
+    evaluation(shared_ptr<const expression> left,
+               shared_ptr<const expression> right,
+               string token,
+               function<int(int, int)> func);
+    ~evaluation() override;
 
-    string to_string() const override;
-    shared_ptr<const Expr> simplify() const override;
+    operator string() const override;
+    shared_ptr<const expression> simplify() const override;
 
    private:
-    shared_ptr<const Expr> left_;
-    shared_ptr<const Expr> right_;
+    shared_ptr<const expression> left_;
+    shared_ptr<const expression> right_;
     string token_;
     function<int(int, int)> func_;
 };

cpp/casting.cpp

@@ -2,22 +2,22 @@
 
 #include <iostream>
 
-class Printable {
+class printer {
    public:
     virtual void print() const = 0;
 };
 
-class CustomInt;
-class CustomFloat;
+class custom_int;
+class custom_float;
 
-class CustomInt : public Printable {
+class custom_int : public printer {
    public:
-    CustomInt();
-    CustomInt(int number);
+    custom_int();
+    custom_int(int number);
 
     operator int() const;
     operator float() const;
-    operator CustomFloat() const;
+    operator custom_float() const;
 
     void print() const override {
         std::cout << "CustomInt: " << value_ << std::endl;
@@ -27,14 +27,14 @@ class CustomInt : public Printable {
     int value_;
 };
 
-class CustomFloat : public Printable {
+class custom_float : public printer {
    public:
-    CustomFloat();
-    CustomFloat(float a);
+    custom_float();
+    custom_float(float a);
 
     operator int() const;
     operator float() const;
-    operator CustomInt() const;
+    operator custom_int() const;
 
     void print() const override {
         std::cout << "CustomFloat: " << value_ << std::endl;
@@ -46,41 +46,41 @@ class CustomFloat : public Printable {
 
 // Implementations
 
-CustomInt::CustomInt() : value_(0) {}
-CustomInt::CustomInt(int number) : value_(number) {}
-CustomInt::operator int() const {
+custom_int::custom_int() : value_(0) {}
+custom_int::custom_int(int number) : value_(number) {}
+custom_int::operator int() const {
     return value_;
 }
-CustomInt::operator float() const {
+custom_int::operator float() const {
     return static_cast<float>(value_);
 }
-CustomInt::operator CustomFloat() const {
-    return CustomFloat(static_cast<float>(value_));
+custom_int::operator custom_float() const {
+    return custom_float(static_cast<float>(value_));
 }
 
-CustomFloat::CustomFloat() : value_(0.0f) {}
-CustomFloat::CustomFloat(float a) : value_(a) {}
-CustomFloat::operator int() const {
+custom_float::custom_float() : value_(0.0f) {}
+custom_float::custom_float(float a) : value_(a) {}
+custom_float::operator int() const {
     return static_cast<int>(value_);
 }
-CustomFloat::operator float() const {
+custom_float::operator float() const {
     return value_;
 }
-CustomFloat::operator CustomInt() const {
-    return CustomInt(static_cast<int>(value_));
+custom_float::operator custom_int() const {
+    return custom_int(static_cast<int>(value_));
 }
 
 int main() {
-    CustomInt custom_int(5);
-    CustomFloat custom_float(3.14f);
+    custom_int custom_int(5);
+    custom_float custom_float(3.14f);
 
     custom_int.print();
     custom_float.print();
 
-    auto casted_float = static_cast<CustomFloat>(custom_int);
+    auto casted_float = static_cast<class custom_float>(custom_int);
     casted_float.print();
 
-    auto casted_int = static_cast<CustomInt>(custom_float);
+    auto casted_int = static_cast<class custom_int>(custom_float);
     casted_int.print();
 
     return 0;

cpp/classes.cpp

@@ -4,16 +4,16 @@
 
 using namespace std;
 
-class SomeClass {
+class some_class {
    public:
-    SomeClass(int i) : member(i) {}
+    some_class(int i) : member(i) {}
     int& alias = member;
     const int& const_alias = member;
     int member;
 };
 
 int main() {
-    auto sc = SomeClass{1};
+    auto sc = some_class{1};
     cout << sc.member << ' ' << sc.alias << ' ' << sc.const_alias << '\n';
     sc.member = 2;
     cout << sc.member << ' ' << sc.alias << ' ' << sc.const_alias << '\n';

cpp/const.cpp

@@ -1,31 +1,32 @@
 /// Copyright (c) RenChu Wang - All Rights Reserved
 
-class ConstMember {
+class const_member {
    public:
-    ConstMember(int x) : member_(x) {}
+    const_member(int x) : member_(x) {}
 
    private:
     const int member_;
 };
 
-class NormalMember {
+class normal_member {
    public:
-    NormalMember(int x) : member_(x) {}
+    normal_member(int x) : member_(x) {}
+    int member() const { return member_; }
 
    private:
     int member_;
 };
 
 int main() {
     // No problem doing this.
-    NormalMember nm{3};
-    nm = NormalMember{4};
+    normal_member nm{3};
+    nm = normal_member{4};
 
-    ConstMember cm{9};
-    // ConstMember& ConstMember::operator=(ConstMember&&)’ is implicitly
+    const_member cm{9};
+    // const_member& const_member::operator=(const_member&&)’ is implicitly
     // deleted because the default definition would be ill-formed
     //
     // operator= is deleted because of const member.
     //
-    //  cm = ConstMember{100};
+    //  cm = const_member{100};
 }