c++类----class

++什么是类？

c是面向过程的编程语言，c++是面向对象的编程语言，而c++之所以属于面向对象的语言就是因为类的存在，那么究竟什么是类呢？

---

类的定义

    类是定义同一类所有对象的变量和方法的蓝图或原型。

类是不能直接拿来使用的，你在使用它之前必须首先对它进行实例化，建立这种类型的一个对象，打个比方如果说对象是一栋楼的话，类就相当于建这所大楼的图纸。如果你想使用这栋大楼的话你只有设计图纸有什么用，你必须照着图纸把楼建起来才可以使用这栋大楼。 由类生成对象的过程就相当于根据图纸建楼的过程。

---

类的组成

类本身是对自然界具有相同特征的群体的抽象，它代表的是某一类事物。
比如说：哈士奇，萨摩耶，泰迪就是一类事物，它们都是狗；它们具有一些相同的属性和行为。

相同属性：毛色，身高，体重，性别…..
相同行为：叫，跑，睡觉……
把它抽象成类之后：

class Dog   //类名
{
public:
    Dog();     //构造函数
    ~Dog();    //析构函数
    //成员函数
    void shout();  
    void run();
    void sleep();
private:
    //成员变量
    char name[20];
    char color[10];
    double height;
    double weight;
    char sex[3];
};

这样就抽象出了一个简单的类，虽然简单但它包括了类的基本组成。

类名：类的名字，上面例子中类名就是Dog 类名命名可以为 字母，数字和下划线组合但不能以数字开头
构造函数：用来生成对象时，对对象进行初始化使用，可以根据初始化参数的不同重载多个构造函数。
析构函数：与构造函数相反，在类销毁时用来释放类中使用new等关键字在堆区分配的内存，避免内存泄漏，需要 根据具体的类具体 编写，会在生成的对象结束其生命周期时由系统自动调用。
成员变量：用来保存类的一些属性的变量叫做成员变量，可以是基本的数据类型，类，结构体等。
成员函数：主要描述的是类的行为,最要作用是对类内封装的成员变量的操作。

---

类成员的访问权限

类的成员包括成员变量和成员函数两类，而修饰类成员的访问权限有三种：

---

private：私有
私有的意思是只能我自己内部用，对于外部是不可见的，也就是说如果一个类的某个成员为私有，那么通过这个类生成的对象都无法访问到这个私有成员。并且这个成员也不能被其子类继承

#include<iostream>
#include<string>
using namespace std;

class  Person
{
private:
    string _name;
    void Person::SetName(string str)
    {
        _name = str;
    }
};

int main()
{
    Person son1;
    son1._name = "小明";//非法访问
    son1.SetName("小明");//非法访问
    system("pause");
    return 0;
}

可以看出

无论是成员函数还是成员变量只要被声明为了私有，那么对于类外它就是隐藏的，所以一般用private修饰成员变量防止类外的非法访问，起到封装的效果。

---

public：公有
共有的意思也就是公共的，所以它在类外是可见的，通过类生成对象后我们就可已通过对象对共有的成员进行访问了。且公有成员是可以被子类继承的。

#include<iostream>
#include<string>
using namespace std;

class  Person
{
private:
    string _name;
public:
    Person(string name) 
    {
        _name = name;
    };
    ~Person() {};
    void Person::SetName(string str)
    {
        _name = str;//私有成员只在类内可见，在这里为私有成员变量赋值
    }
    string Person::GetName()
    {
        return _name;
    }
};


int main()
{
    Person *son1=new Person("小明");  //通过调用构造函数，将生成对象名字初始化为小明
    cout << son1->GetName()<<endl;    //调用公有成员函数输出对象的名字
    son1->SetName("小小明");         //调用共有成员函数将对象的名字改为小小明
    cout<<son1->GetName()<<endl;    
    system("pause");
    return 0;
}

可以看出：

成功在类外通过对象访问到了类的共有成员。配合private，public通常用来修饰成员函数，对外提供功能接口方便使用，并隐藏内部实现细节。

---

protected：保护
protected介于private和public之间，和private类似都不能在类外直接访问，都可以在类内访问，它和private不同的地方是他可以被继承。
且可以在派生类中通过派生类对象访问基类的protected成员（这也是唯一通过对象访问protected成员的方法）。

#include<iostream>
#include<string>
using namespace std;

class  Point
{
protected:
    int _point_x;
    int _point_y;
    void Point::setPoint(int x, int y)
    {
        _point_x = x;
        _point_y = y;
    }


};
//子类DerivedPoint 继承自基类Point
class DerivedPoint :public Point
{
public:

    void DerivedPoint::CoutPoint()
    {
        //在派生类内部通过派生类对象访问基类protected成员
        DerivedPoint point1;
        point1.setPoint(3, 4);
        cout << "(" << point1._point_x << "," << point1._point_y << ")" << endl;
    }
};

int main()
{
    DerivedPoint temp;
    temp.CoutPoint();
    system("pause");
    return 0;
}

可以看出：

基类的被pretected修饰的两个成员变量_point_x和_point_y 成功被其子类DerivedPoint继承，并可以通过子类的内部访问。

总结：
private：  只可以被   1.该类中的函数 2.其友元函数访问。
protected：只可以被  1.该类中的函数 2.其友元函数  3.子类的函数访问。
public：   只可以被     1.该类中的函数 2.其友元函数  3子类的函数访问，4.该类的对象访问。

---

类成员函数的定义

类的成员函数有两种方式一种就是上文使用的在直接在类的内部进行定义。
还有一种是在类外定义：

#include<iostream>
#include<string>
using namespace std;

class  Person
{
private:
    string _name;
public:
    //类内声明
    void Person::SetName(string str);
    string Person::GetName();

};

//类外定义
void Person::SetName(string str)
{
    _name = str;
}

string Person::GetName()
{
    return _name;
}

int main()
{
    Person *son1 = new Person(); 
    son1->SetName("小明");         
    cout << son1->GetName() << endl;
    system("pause");
    return 0;
}

可以看出：

虽然成员函数的定义放在了类外，但仍然起到了相同的效果。相比较直接在类内部定义还是比较推荐这种在类外定义成员函数的方法，这样可以避免类内代码过于复杂，既不好查看又不好修改。