C++学习 面向对象

 参考书籍《从新手到高手C++全方位学习》

 
==================面向对象=================================
面向对象的四个特征：抽象、封装、继承、多态
	
面向过程：思想是将一个程序分成若干个过程，然后写出每个过程的算法

面向对象：它将自然界的所有事物都看做不同的实体，也就是对象。每种对象都有自己的
状态和行为。这些不同的对象之间相互联系而又相互作用。从而构成前边万化的大自然。
在面向对象的程序设计中，程序员不需要考虑数据结构和操作函数，只需考虑对象即可。

#include<iostream>
using namespace std;
class 人类   
{
public :     共有的意思是该类的对象可以直接访问这些成员
	void 获得身高();
	void 获得体重();
private :    表示它后面的成员都是私有的，不能被对象直接访问，必须通过共有的成员函数才能访问
	int 身高;
	int 体重;
};
void main(void)
{
	人类 Gino;  定义了一个对象Gino
}

声明了一个类，并没有分配内存。它告诉编译器类的大小。类的大小是根据变量来定的
例子中的类的大小是8个字节（一个int占4个字节）。该类的方法是不占内存的
private 表示后面的数据成员是要被各个对象封装的，都是对象私有的，不能共享。

要选定一种命名习惯，并在整个程序中都使用这种习惯表示，这样会增强可读性。
===============================================================
#include<iostream>
using namespace std;
class student
{
public :
	void getStature(){cout<<stature;}  // 函数定义方法1 声明的同时进行定义
	void setStature(int x){stature = x;}
	void getSex();
	void setSex(int y);
private :
	int stature;
	int sex;
};
 void student::getSex()  //函数定义方法2 在类外面定义函数【类中声明，一定在类外定义】
 {
	cout<<sex;
 }
 void student::setSex(int y)
 {
	sex = y;
 }

int main()
{
	student Gino;
	Gino.setStature(100);   //共有方法访问私有成员，私有成员不能直接访问。
	cout<<"Gino's stature";
	Gino.getStature();
	cout<<endl;
	Gino.setSex(1);
	cout<<"Gino's gender";
	Gino.getSex();

	return 0;
}
===============================================================
不能给类赋值，就正如不能给int这个类型赋值一样。

函数是用来执行一定功能的代码块
成员函数则是只能被类的对象所使用的函数。

===============================================================
类的成员默认为私有！！！

#include<iostream>
using namespace std;
class Human
{
//public:
    int weight;
public :
    void setWeight(int x )       赋值操作
    {
        if(x>0 && x<100)
        {
             weight = x;
        }
        else
            cout<<"enter a number greater than 0 and less than 100"<<endl;
    }
    int show(){return weight;}  读取操作

};
int main(void)
{
    Human Gino;
    Gino.setWeight(90);
    cout<<Gino.show()<<endl;

    return 0;
}
一般将类的数据数据成员设置为私有，而使用共有的函数来访问它们。
这样的好处是数据的赋值和读取时分开操作的，修改其中一个不需要考虑另一个
私有数据成员以后，各个对象也不可以直接访问并修改数据，提高了安全性。

=========================内联函数==================================
为什么将成员函数的声明和定义分开写？
【因为写在一起，该函数会自动成为内联函数，如果该函数代码很长，重复调用会增大程序体积】

当定义函数以后，编译器会为其在内存中创建一个指令集。当调用这个函数的时候
程序就得来回跳转，影响执行效率。为了解决这个问题，C++提供了inline声明函数
inline int function();
则编译器不会创建真正的函数，而只是将这个内联函数的所有代码拷贝到调用函数中，
这样在执行调用函数的时候就不用来回跳转，可提高效率。

但是提高效率的代价是增加代码长度，增大程序体积。
使用条件：当函数很小、代码短的时候使用内联函数。

一般内联函数：
#include<iostream>
using namespace std;
inline int fun(int x);  //声明为内联函数
int main(void)
{
    int x;
    cout<<"enter a number:";
    cin>>x;
    cout<<endl;
    cout<<fun(x)<<endl;   //不会跳转

    return 0;
}
int fun(int x)    //定义函数
{
    return x;   //函数体的代码会被直接拷贝到调用函数fun(x)处
}

成员内联函数:
#include<iostream>
using namespace std;
class A
{
public :
    inline void fun( int m ); //类中声明 一定在类外定义【将成员函数声明为内联函数】
    int show(){return x;}    //写在一起自动转换为内联函数【成员函数是内联函数】
private :
    int x;
};  //分号！！！
int main(void)
{
    A a;
    int x;
    cout<<"enter a number:";
    cin>>x;
    a.fun(x);   //不会跳转
    cout<<a.show();

    return 0;
}
void A::fun(int m)    //类外面定义函数
{
    x=m;
}

=========================const 成员函数==============================
若不想让成员函数修改成员变量的值，就将【成员函数】声明为const

#include<iostream>
using namespace std;
class A
{
public :
    void fun(int x , int y) {i=x;j=y;} //这里如果声明为const就会报错
    void print()const{cout<<"两数相乘为："<<i*j<<endl;}
private :
    int j;
    int i;
};
int main(void)
{
    A a;
    a.fun(2,4);
    a.print();

    A b;
    b.fun(3,4);
    b.print();
    return 0;
}

===========================构造函数===================================
#include<iostream>
using namespace std;
class rectangle
{
public :
    rectangle(int l,int w){length=l;width=w;}  //构造函数 是内联函数 无返回值
    retangle(){}        //这就是默认构造函数
    int area(){return length*width;}
private :
    int length;
    int width;
};
int main(void)
{
    rectangle a(3,4);
    cout<<"面积是："<<a.area();
    rectangle b; //如不提供构造函数，那么系统会自动创建一个默认的构造函数
    return 0;
}

===========================析构函数================================
析构函数用于在对象销毁以后清除它所占的内存空间
每个对象在创建的时候都会自动调用该类的默认构造函数
对象生命结束时，编译器会自动调用类的默认析构函数来释放掉该对象所占的内存
#include<iostream>
using namespace std;
class A
{
public :
    A(){};
    ~A(){}; //析构函数无返回值、无参数  一个类只有一个析构函数
};
int main(void)
{
    A a; //A a[2];
    
    return 0;
}
 创建对象数组A a[2]会执行两次构造函数，
 程序结束时，会调用两次析构函数,释放两个对象所占用的内存