C++基础讲解第二期（超详细）每天更新哈，大家一起加油

一、类和对象

1、面向对象的编程介绍

面向对象将系统通过交互作用完成特定的功能的对象的集合，每个对象都有自己的方法，来管理自己的数据，也就是说只有对象内部的代码能够操作对象内部的数据。

2、面向对象的优缺点

优点：
重要性：利于开发速度，如果想要开发某个功能，发现实现起来很麻烦，这时候使用c++就能很快的解决。
封装性/抽象性：结构清晰，很标准，规范化，易于理解，可读性强。
继承：容易扩展，大框架不变的情况下，很容易开发出自己的功能

缺点：
相比于面向过程的C语言，运行效率会下降百分之十。

3、类和对象

a、概念

C++是一门面向对象的语言，理解C++，首先要理解类(class) 和对象(object) 这两个概念。
C++中的类可以堪称C语言中的结构体的升级版，结构体是一种构造类型，可以包含若干成员变量，每个成员变量的类型可以不同。也可以通过结构体来定义结构体变量。

关于class的几点：
1、在类中定义的每一个成员最后有一个分号；它是类的一部分，表示类定义结束，不能省略。
2、一个类可以创建多个对象，每个对象都是类的一个变量。
3、类是一种复杂的数据类型，本身不占内存，而对象是一个实实在在的数据，需要占用内存空间。
4、对象可以通过点号" . "来访问类的变量和类的方法，这和结构体类似。
5、成员函数是一个类的成员出现在类中，它的作用范围由类来决定，而普通函数是独立的，作用范围是全局或者某个命名空间。

#include
#include

using namespace std;

struct student//默认是公有权限
{
    int age;
    char *name;
};

class Student //默认是私有权限
{
    public:
        char *name;
        int age;

        void print()
        {
            cout << "age = " << age << " name = "<< name <<endl;
        }
};

int main()
{
    student s1;
    s1.age = 1;
    s1.name = "ya";

    Student s2;
    s2.age = 2;
    s2.name = "wang";
    s2.print();

    return 0;
}

b、类的访问控制

访问级别分为public，protected，private三个关键词控制，在使用这三个关键词之前先搞明白一件事情，那就是类的内部和类的外部。

public:共有属性，凡是在它下面定义的属性或方法，不管在类的内部或者类的外部，都可以访问。
protected：保护属性，凡是在它下面定义的属性或者方法，只能在类的内部和有继承关系的类中访问
private：私有属性，凡是在它下面定义的属性或者方法，只能在类的内部访问

#include
using namespace std;

class Test
{
public:
    int a;
    void f1()
    {

    }

protected://保护属性，用于继承
    int b;
    void f2()
    {

    }

private://私有属性，只能在类的内部访问，不能在类的外部访问
    int c; //类的成员变量，属性
    void f3()//类的成员函数，方法
    {

    }
};

int main()
{
    Test t1;
    t1.a = 1;
    //t1.b = 2; 保护成员无法通过外部访问
    //t1.c = 3; 私有成员无法通过外部访问

    return 0;
}

c、访问控制的几点使用说明

1、public和protected可以出现多次，有效范围是一个关键字出现之前
2、struct结构体中默认为公有，class类中默认为私有

d、类中元素的说明

#include
using namespace std;

class Circle
{
private://一般将类的成员变量设为私有
    int m_r;
    double m_s;

public://将类的成员函数设为公有，暴露出来
    void set_r(int r)
    {
        m_r = r;
    }

    double Get_s()
    {
        m_s = 3.14 * m_r * m_r;
        return m_s;
    }
};

int main()
{
    Circle c; //创建对象
    c.set_r(2);
    cout << "圆的面积是：" << c.Get_s() << endl;
    
    return 0;
}

在实际开发中，我们通常类的声明放在头文件中，而将成员函数的定义放在源文件中。

//student.h
#ifndef _H_STUDENT_
#define _H_STUDENT_

#include
using namespace std;

class Student
{
private:
    int m_age;

public:
    void setage(int age);//声明类的成员函数，函数在其他地方实现

    int getage();
};

#endif

//student.cpp
#include "student.h"
void Student::setage(int age)
{
    m_age = age;
}

int Student::getage()
{
    return m_age;
}

//main.cpp
int main()
{
    Student s1;
    s1.setage(18);

    cout << "age = " << s1.getage() << endl;
    
    return 0;
}

练习：设计立方体类（Cube）求立方体的面积(2ab+2bc+2ac) 和体积(abc)，并且判断两个立方体是否相等

要求：
私有成员变量：长宽高
成员函数：求面积，求体积
全局函数，判断两个立方体是否相等

//cube.h
#ifndef _H_CUBE_
#define _H_CUBE_
#include 
using namespace std;

class Cube
{
    private:
        int m_a, m_b, m_c;
    
    public:
        void set_lwh(int l, int w,int h);
        double get_s();
        double get_v();
        int get_length();
        int get_wide();
        int get_high();
};

void Compare(Cube c1, Cube c2);
#endif

//cube.cpp
#include "cube.h"
void Cube::set_lwh(int l, int w, int h)
{
    m_a = l;
    m_b = w;
    m_c = h;
}

double Cube::get_s()
{
    return (2*m_a*m_b + 2*m_a*m_c + 2*m_b*m_c);
}

double Cube::get_v()
{
    return (m_a*m_b*m_c);
}

int Cube::get_length()
{
    return m_a;
}

int Cube::get_wide()
{
    return m_b;
}

int Cube::get_high()
{
    return m_c;
}
void Compare(Cube c1, Cube c2)
{
   if(c1.get_high() == c2.get_high() && c1.get_length() == c2.get_length() && c1.get_wide() == c2.get_wide())
   {
        cout<<"相等"<<endl;
   }
   else
   {
        cout<<"不相等"<<endl;
   }
}

//main.cpp
#include "cube.h"
int main()
{
    Cube cube1;
    cube1.set_lwh(1,2,3);

    Cube cube2;
    cube2.set_lwh(3,2,1);

    cout <<"长方体1的面积为：" << cube1.get_s() << endl;
    cout <<"长方体1的体积为：" << cube1.get_v() << endl;

    cout <<"长方体2的面积为：" << cube2.get_s() << endl;
    cout <<"长方体2的体积为：" << cube2.get_v() << endl;

    Compare(cube1,cube2);
}