c++和Golang面向对象的和思考c++和golang

前言

封装、继承和多态是面向对象编程中最基本的三个概念，C 是一种真正的面向对象编程语言，它支持类和对象、继承和多态等常见的面向对象特性。C 的面向对象模型非常强大和灵活，允许您创建复杂的系统，并提供高度的可重用性和可扩展性。Go 语言支持面向对象编程，但与传统的面向对象语言不同，Go 语言采用了更加简单和轻量级的面向对象模式。在 Go 语言中，您可以使用结构体（struct）和方法（method）来实现面向对象编程。
下面就从封装继承以及多态这三个面向对象的基本概念分别说明他们的异同点。

封装

C 中的封装通过类定义实现，可以使用public, private, protected关键字控制成员的访问权限。C 类的一个例子：

class Person {
private:
    int age;
    string name;
public:
    void setAge(int a) {
        age = a;
    }
    int getAge() {
        return age;
    }
    void setName(string n) {
        name = n;
    }
    string getName() {
        return name;
    }
};

Go语言中的封装通过结构体实现，通过将属性设置为小写字母开头的变量名来限制外部的访问权限。下面是一个Go结构体的例子：

type Person struct {
    age  int
    name string
}

func (p *Person) SetAge(a int) {
    p.age = a
}
func (p *Person) GetAge() int {
    return p.age
}
func (p *Person) SetName(n string) {
    p.name = n
}
func (p *Person) GetName() string {
    return p.name
}

在这个例子中，age和name被设置为结构体的私有成员，只能通过公有的成员函数来访问和修改。

继承

C 中可以通过类之间的继承实现代码复用，派生类可以继承基类的成员和方法。下面是一个简单的C 继承例子：

class Animal {
public:
    void sleep() {
        cout << "zzz..." << endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "woof woof!" << endl;
    }
};

int main() {
    Dog dog;
    dog.sleep();
    dog.bark();
    return 0;
}

在这个例子中，Dog类继承了Animal类的sleep()方法，同时添加了自己的bark()方法。

Go语言中没有类的概念，也没有继承的能力。但是Go语言提供了组合的机制，可以将一个结构体嵌入到另一个结构体中来实现代码复用。下面是一个简单的Go组合例子：

type Animal struct{}

func (a *Animal) Sleep() {
    fmt.Println("zzz...")
}

type Dog struct {
    *Animal
}

func (d *Dog) Bark() {
    fmt.Println("woof woof!")
}

func main() {
    dog := &Dog{&Animal{}}
    dog.Sleep()
    dog.Bark()
}

在这个例子中，Dog结构体嵌入了Animal结构体，并通过组合实现代码复用。

多态

在C 中，实现多态需要使用虚函数。虚函数是一种特殊的成员函数，在基类中声明为虚函数，派生类可以重写该函数，并根据自己的需求提供不同的实现。当通过指针或引用调用一个对象的虚函数时，会根据对象的实际类型动态地选择相应的函数。

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Circle" << endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        cout << "Square" << endl;
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle();
    shapes[1] = new Square();

    for (int i = 0; i < 2; i  ) {
        shapes[i]->draw(); // 多态调用
        delete shapes[i];
    }

    return 0;
}

在Go语言中，没有虚函数的概念，也不支持运行时多态。但是Go语言提供了接口（interface）来实现编译时多态。接口定义了一组方法，只要一个类型实现了这些方法，就可以被认为是这个接口类型的实例。

type Shape interface {
    Draw()
}

type Circle struct{}

func (c *Circle) Draw() {
    fmt.Println("Circle")
}

type Square struct{}

func (s *Square) Draw() {
    fmt.Println("Square")
}

func main() {
    shapes := []Shape{&Circle{}, &Square{}}
    for _, s := range shapes {
        s.Draw() // 多态调用
    }
}

总结

C 和Go语言的面向对象编程特性在实现上有所不同，但都能够满足面向对象编程的基本需求。C 更加传统，支持类继承、虚函数等特性；而Go语言则更注重代码的简洁性和可读性，提供了结构体嵌入和接口等特性来实现代码复用和多态

这篇好文章是转载于：学新通技术网