笔记：C++学习之旅---面向对象程序的设计1

笔记：C++学习之旅---面向对象程序的设计1

面向对象的主要特征

1.抽象

2.封装

3.继承

4.多态

抽象：将程序的每一部分都看作一个抽象的对象，即程序有一组抽象的对象组成的更复杂点，这些对象根据他们相同的特征有进一步组成了一个类。

封装：将每个数据封装在各自的类中，有设置了多种访问权限，别的类可以在允许的情况下访问该类中的数据，不允许的情况下则无法访问该数据，从而避免了非法操作和出错的可能性。

继承：将一个类中的所有数据和功能集成过来，然后再进行改写。

多态：把不同的对象，调用相同的名称函数却导致不同的行为或者结果的现象称为多态。

类：由若干个变量和相关的函数组成，而对象则可以拥有这些变量和函数。

类中定义变量

#include<iostream>

#include<conio.h>

usingnamespacestd;

classHuman//相当于c中的结构体,Human类，类中可以直接声明函数或者变量就可以

{

public://公有成员

   voidGetStature()

            {

                cout<<stature<<endl;

            }

            voidSetStature(intx)//通过成员函数为私有的成员变量（stature）赋值；

            {

                stature =x;

            }

   voidGetWeight();

            voidSetWeight(inty);

private://私有成员,只能通过成员函数间接进行访问;

            intstature;

            intweight;

};

/*在类外定义函数*/

voidHuman::SetWeight(inty)

{

    weight =y;

}

voidHuman::GetWeight()

{

    cout<<weight<<endl;

}

intmain()

{

            inta = 0;

            intb = 0;

            cout<<"请输入一个a\n";

            cin>>a;

   HumanMike;// 定义一个对象;而java中是 Human Mike = new Human（）；new一块，定义一个对象;

            Mike.SetStature(a);

            Mike.GetStature();//通过对象访问一个函数

            cout<<"请输入一个b\n";

            cin>>b;

            Mike.SetWeight(b);

            Mike.GetWeight();

            getch();

            return0;

}

生命这个类并没有为人类分配内存，它只是告诉编译器：人类是什恶魔，包含哪些数据类型，功能是什么,同时告诉类有多大，类的大小根据成员变量决定，比如上面代码中的成员变量一个是身高，一个是体重，都是int型，一个int型占4个字节，所以该类的大小就是8个字节.该类的方法不占用内存，因为我们没有为方法“GetStature()”和“GetWeight()”生命类型，它们的返回值是void。

定义类或者对象容易犯的错误

1.我们不能直接给类赋值，如：Human.weight = 100,这是错误的,因为类是个抽象的名词，它泛指所有的人，你无法给这个抽象的名词赋值，我们必须用这个抽象的名词来具体化某一个人如：Human Tom；

             Tom。weight =100；这样才对

2.对象只能调用类中存在的成员。

注意要点：

1：要使用关键字class来声明一个类

2：要使用类名来定义一个对象。

3：不能混淆声明和定义，声明是说明该类是什么，定义是为一个对象分配内存.

4：要使用点运算符来访问类的成员。

5：要使用对象与点运算符来访问对象的数据成员并给它们赋值。

6：不能混淆类和对象，不能给类赋值。

最后：函数是用来执行一定功能的代码块，成员函数则是只能被类的对象所使用的函数，对象只能使用该类提供的函数，假如类没有提供某个函数，那么对象就不具备该函数.

public：公有的，意思是该类的对象可以直接访问这些成员。

private：表示他后面的成员都是私有的，另外如果类中没有声明，那么程序默认成员为私有的，私有成员不能被对象直接访问，必须通过在类中设定的接口函数才能访问.

#include<iostream>

#include<conio.h>

usingnamespace std;

classHuman

{

            int weight; //类的成员默认为私有的，私有成员不能被对象直接访问；

};

intmain()

{

            Human Tom;

            Tom.weight = 150;

            cout<<"汤姆的体重为：" <<Tom.weight<<endl;//所以是无法打印出来的，程序报错

            Human Mike;

            Mike.weight = 160;

            cout<<"迈克的体重为：" <<Mike.weight<<endl;//所以是无法打印出来的，程序报错

            getch();

   return 0;

}

为什么要这么麻烦的设置私有成员，然后通过公有函数来访问它呢？

     主要是为了提高代码的安全性，防止错误的输入和输出。比如说我们输入了一个超过取之方位的书，又或者说有的时候我们要控制用户所输入数值的范围，比如说在例子当中我们要控制用户输入一个大于0而小于100的数字，那么就可以直接在接口函数set中设定：

#include<iostream>

#include<conio.h>

usingnamespacestd;

classHuman

{

public:

            voidset(intw)

            {

                        if(w>0 &&w< 100)

                        {

                    weight =w;

                        }

                        else

                        {

                            weight = 0;

                                    cout<<"请将set函数中的参数设置为大于0而小于100的数字，否则默认返回0"<<endl;

                        }

            }

            intshow()

            {

               returnweight;

            }

private:

            intweight;//类的成员默认为私有的，私有成员不能被对象直接访问

};

intmain()

{

            HumanTom;

            Tom.set(80);

            cout<<"汤姆的体重为："<<Tom.show()<<endl;

            HumanMike;

            Mike.set(90);

            cout<<"迈克的体重为："<<Mike.show()<<endl;

            getch();

           return0;

}

     一般我们将类的数据成员设置为私有，而是用类的共有函数来访问它们，这样的好处是数据的赋值与读取分开操作，赋值函数不需要考虑读取函数是如何工作的，读取函数中的代码的改变也不会影响到赋值函数。赋值函数不用殷都区函数中的代码的改变而改动自己的代码，而且由于将数据成员私有以后，各个对象不可以直接访问并修改数据，无形中又提高了数据的安全性，因此设置私有数据成员可以使程序更容易维护，并且避免了一些不应有的错误。

函数的声明与定义

#include<iostream>

#include<conio.h>

usingnamespacestd;

classHuman

{

public:

            voidset(intw);//函数的声明，在类中声明函数

            

            intshow()

            {

               returnweight;

            }

private:

            intweight;//类的成员默认为私有的，私有成员不能被对象直接访问

};

/*将类中函数的声明与函数分开写*/

voidHuman::set(intw)//在类外写函数，只需在函数前面加上Human::   ::域运算符，说明这个函数只属于这个类

            {

                        if(w>0 &&w< 100)

                        {

                    weight =w;

                        }

                        else

                        {

                            weight = 0;

                                    cout<<"请将set函数中的参数设置为大于0而小于100的数字，否则默认返回0"<<endl;

                        }

            }

intmain()

{

            HumanTom;

            Tom.set(80);

            cout<<"汤姆的体重为："<<Tom.show()<<endl;

            HumanMike;

            Mike.set(90);

            cout<<"迈克的体重为："<<Mike.show()<<endl;

            getch();

   return0;

}

为什么要将成员函数的声明与定义分开，直接使用合并的函数不是更加简介而又方便？

1：一般来说当我们定义了一个函数后，编译器就会在内存中为其创建一个指令集，当我们调用这个函数时，程序就会跳转到该指令集处，当函数运行完毕后，程序又会返回到原来执行函数的下一行继续执行。假如对该函数执行了上百次的调用，那么来回跳转影响了程序的执行效率。

2：内联函数编译器将不会创建真正的函数，而只是将这个内联函数的所有代码拷贝到调用函数中，这样程序在执行调用该函数时就不需要来回跳转，自然就会提高程序的运行效率。C++对此的解决方法是，使用关键字inline声明函数.

3:声明和定义不分开也就相当于内联函数，内联函数只能在调用函数代码量小的情况下有效提高速度，但是函数体很多代码并且重复调用该函数多次的话，会不断的赋值该函数体的代码将会造成程序的增大。所以我们需要将函数的声明与定义分开

#include<iostream>

#include<conio.h>

usingnamespacestd;

classA

{

public:

            inlinevoidfunc(intnum);//声明一个内联函数

  //void get();

            //int get();不能在类中同时声明并且定义函数，这是错误的

            intget()

            {

               returnx;

            }

private:

            intx;

};

voidA::func(intnum)//定义一个内联函数

{

    x =num;

}

/*

void A::get()

{

    cout<<x<<endl;

}*/

intmain()

{

            Aa;

            intnum = 0;

            cout<<"请输入一个数字\n";

            cin>>num;

            a.func(num);

            //a.get();

            //cout<<"输入的数字为："<<a.get()<<endl;

            getch();

            return0;

}

头文件与源文件一般都是分开写，头文件中一般写包含的库和类的定义（相当于C里面的定义数据结构和写头文件，以及函数的声明）

如果不想要某个成员函数修改成员变量的值，那么不妨将这个成员函数声明为const。

构造函数（构造一个对象）

构造函数的作用：可以在创建某个类的对象的时候，对该对象的数据进行初始化，构造函数没有返回值。

默认构造函数：如果没有创建构造函数，当创建对象时，系统会默认创建一个空的构造函数。

#include<iostream>

#include<conio.h>

usingnamespacestd;

classrectangel

{

public:

            rectangel(intl,intw)//构造函数, 构造函数没有返回值

            {

                length =l;

                        width =w;

            }

            intarea()//求长方形的面积

            {

               returnlength*width;

            }

private:

            intlength;

            intwidth;

};

intmain()

{

            intx = 0;

            inty = 0;

            cout<<"请输入两个数x和y\n";

            cin>>x>>y;

           rectangela(x,y);//构造函数在创建某个类的对象的时候，就对该类对象数据进行了初始化

            cout<<"长方形的面积:"<<a.area()<<endl;

            getch();

            return0;

}

构造函数 是一种特殊的方法 主要用来在创建对象时初始化对象 即为对象成员变量赋初始值 
总与new运算符一起使用在创建对象的语句中 特别的一个类可以有多个构造函数 可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载
构造函数与其他方法的区别 
1.构造函数的命名必须和类名完全相同;而一般方法则不能和类名相同.
2.构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的.
3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用,一般方法在程序执行到它的时候被调用.
4.当定义一个类定义的时候，通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略不去Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的.而一般方法不存在这一特点

补充：
构造函数的名字必须与类名相同，而且不可以有返回值，也不能有return 语句。

构造函数往往执行一些初始化的操作。

析构函数（销毁一个对象）

1：析构函数与构造函数相反，构造函数用于构造一个对象，析构函数则用于在对象被销毁后清楚它所占用的内存空间，比如说它可以清除构造函数创建的内存。

2：析构函数是没有返回值的。

#include<iostream>

#include<conio.h>

usingnamespacestd;

classA

{

public:

            A()

            {

                cout<<"构造函数执行完毕!\n";

            }

            ~A()//创建一个析构函数，析构函数没有返回值以及参数，并且一个类只有一个析构函数;

            {

                cout<<"析构函数执行完毕!\n";

            }

};

intmain()

{

            Aa;

            return0;

}

构造一个对象数组

/*析构函数数组*/

#include<iostream>

usingnamespacestd;

classA

{

public:

            A();

            ~A();

};

A::A()

{

    cout<<"构造函数执行完毕"<<endl;

}

A::~A()

{

    cout<<"析构函数执行完毕"<<endl;

}

intmain()

{

            Aa[2];//声明一个对象数组

            return0;

}

  

对象：是指能存储数据病具有某种类型的内存空间