笔记:C++学习之旅---面向对象程序的设计1
面向对象的主要特征
1.抽象
2.封装
3.继承
4.多态
抽象:将程序的每一部分都看作一个抽象的对象,即程序有一组抽象的对象组成的更复杂点,这些对象根据他们相同的特征有进一步组成了一个类。
封装:将每个数据封装在各自的类中,有设置了多种访问权限,别的类可以在允许的情况下访问该类中的数据,不允许的情况下则无法访问该数据,从而避免了非法操作和出错的可能性。
继承:将一个类中的所有数据和功能集成过来,然后再进行改写。
多态:把不同的对象,调用相同的名称函数却导致不同的行为或者结果的现象称为多态。
类:由若干个变量和相关的函数组成,而对象则可以拥有这些变量和函数。
类中定义变量
#include
<iostream>
#include
<conio.h>
using
namespace
std;
class
Human
//相当于c中的结构体,Human类,类中可以直接声明函数或者变量就可以
{
public
:
//公有成员
void
GetStature()
{
cout<<stature<<endl;
}
void
SetStature(
int
x
)
//通过成员函数为私有的成员变量(stature)赋值;
{
stature =
x
;
}
void
GetWeight();
void
SetWeight(
int
y);
private
:
//私有成员,只能通过成员函数间接进行访问;
int
stature;
int
weight;
};
/*在类外定义函数*/
void
Human
::SetWeight(
int
y
)
{
weight =
y
;
}
void
Human
::GetWeight()
{
cout<<weight<<endl;
}
int
main()
{
int
a = 0;
int
b = 0;
cout<<
"请输入一个a\n"
;
cin>>a;
Human
Mike;
// 定义一个对象;而java中是 Human Mike = new Human();new一块,定义一个对象;
Mike.SetStature(a);
Mike.GetStature();
//通过对象访问一个函数
cout<<
"请输入一个b\n"
;
cin>>b;
Mike.SetWeight(b);
Mike.GetWeight();
getch();
return
0;
}
生命这个类并没有为人类分配内存,它只是告诉编译器:人类是什恶魔,包含哪些数据类型,功能是什么,同时告诉类有多大,类的大小根据成员变量决定,比如上面代码中的成员变量一个是身高,一个是体重,都是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>
using namespace std;
class Human
{
int weight; //类的成员默认为私有的,私有成员不能被对象直接访问;
};
int main()
{
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>
using
namespace
std;
class
Human
{
public
:
void
set(
int
w
)
{
if
(
w
>0 &&
w
< 100)
{
weight =
w
;
}
else
{
weight = 0;
cout<<
"请将set函数中的参数设置为大于0而小于100的数字,否则默认返回0"
<<endl;
}
}
int
show()
{
return
weight;
}
private
:
int
weight;
//类的成员默认为私有的,私有成员不能被对象直接访问
};
int
main()
{
Human
Tom;
Tom.set(80);
cout<<
"汤姆的体重为:"
<<Tom.show()<<endl;
Human
Mike;
Mike.set(90);
cout<<
"迈克的体重为:"
<<Mike.show()<<endl;
getch();
return
0;
}
一般我们将类的数据成员设置为私有,而是用类的共有函数来访问它们,这样的好处是数据的赋值与读取分开操作,赋值函数不需要考虑读取函数是如何工作的,读取函数中的代码的改变也不会影响到赋值函数。赋值函数不用殷都区函数中的代码的改变而改动自己的代码,而且由于将数据成员私有以后,各个对象不可以直接访问并修改数据,无形中又提高了数据的安全性,因此设置私有数据成员可以使程序更容易维护,并且避免了一些不应有的错误。
函数的声明与定义
#include
<iostream>
#include
<conio.h>
using
namespace
std;
class
Human
{
public
:
void
set(
int
w);
//函数的声明,在类中声明函数
int
show()
{
return
weight;
}
private
:
int
weight;
//类的成员默认为私有的,私有成员不能被对象直接访问
};
/*将类中函数的声明与函数分开写*/
void
Human
::set(
int
w
)
//在类外写函数,只需在函数前面加上Human:: ::域运算符,说明这个函数只属于这个类
{
if
(
w
>0 &&
w
< 100)
{
weight =
w
;
}
else
{
weight = 0;
cout<<
"请将set函数中的参数设置为大于0而小于100的数字,否则默认返回0"
<<endl;
}
}
int
main()
{
Human
Tom;
Tom.set(80);
cout<<
"汤姆的体重为:"
<<Tom.show()<<endl;
Human
Mike;
Mike.set(90);
cout<<
"迈克的体重为:"
<<Mike.show()<<endl;
getch();
return
0;
}
为什么要将成员函数的声明与定义分开,直接使用合并的函数不是更加简介而又方便?
1:一般来说当我们定义了一个函数后,编译器就会在内存中为其创建一个指令集,当我们调用这个函数时,程序就会跳转到该指令集处,当函数运行完毕后,程序又会返回到原来执行函数的下一行继续执行。假如对该函数执行了上百次的调用,那么来回跳转影响了程序的执行效率。
2:内联函数编译器将不会创建真正的函数,而只是将这个内联函数的所有代码拷贝到调用函数中,这样程序在执行调用该函数时就不需要来回跳转,自然就会提高程序的运行效率。C++对此的解决方法是,使用关键字inline声明函数.
3:声明和定义不分开也就相当于内联函数,内联函数只能在调用函数代码量小的情况下有效提高速度,但是函数体很多代码并且重复调用该函数多次的话,会不断的赋值该函数体的代码将会造成程序的增大。所以我们需要将函数的声明与定义分开
#include
<iostream>
#include
<conio.h>
using
namespace
std;
class
A
{
public
:
inline
void
func(
int
num);
//声明一个内联函数
//void get();
//int get();不能在类中同时声明并且定义函数,这是错误的
int
get()
{
return
x;
}
private
:
int
x;
};
void
A
::func(
int
num
)
//定义一个内联函数
{
x =
num
;
}
/*
void A::get()
{
cout<<x<<endl;
}*/
int
main()
{
A
a;
int
num = 0;
cout<<
"请输入一个数字\n"
;
cin>>num;
a.func(num);
//a.get();
//cout<<"输入的数字为:"<<a.get()<<endl;
getch();
return
0;
}
头文件与源文件一般都是分开写,头文件中一般写包含的库和类的定义(相当于C里面的定义数据结构和写头文件,以及函数的声明)
如果不想要某个成员函数修改成员变量的值,那么不妨将这个成员函数声明为const。
构造函数(构造一个对象)
构造函数的作用:可以在创建某个类的对象的时候,对该对象的数据进行初始化,构造函数没有返回值。
默认构造函数:如果没有创建构造函数,当创建对象时,系统会默认创建一个空的构造函数。
#include
<iostream>
#include
<conio.h>
using
namespace
std;
class
rectangel
{
public
:
rectangel(
int
l
,
int
w
)
//构造函数, 构造函数没有返回值
{
length =
l
;
width =
w
;
}
int
area()
//求长方形的面积
{
return
length*width;
}
private
:
int
length;
int
width;
};
int
main()
{
int
x = 0;
int
y = 0;
cout<<
"请输入两个数x和y\n"
;
cin>>x>>y;
rectangel
a(x,y);
//构造函数在创建某个类的对象的时候,就对该类对象数据进行了初始化
cout<<
"长方形的面积:"
<<a.area()<<endl;
getch();
return
0;
}
构造函数 是一种特殊的方法 主要用来在创建对象时初始化对象 即为对象成员变量赋初始值
总与new运算符一起使用在创建对象的语句中 特别的一个类可以有多个构造函数 可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载
构造函数与其他方法的区别
1.构造函数的命名必须和类名完全相同;而一般方法则不能和类名相同.
2.构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的.
3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用,一般方法在程序执行到它的时候被调用.
4.当定义一个类定义的时候,通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略不去Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的.而一般方法不存在这一特点
补充:
构造函数的名字必须与类名相同,而且不可以有返回值,也不能有return 语句。
总与new运算符一起使用在创建对象的语句中 特别的一个类可以有多个构造函数 可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载
构造函数与其他方法的区别
1.构造函数的命名必须和类名完全相同;而一般方法则不能和类名相同.
2.构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的.
3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用,一般方法在程序执行到它的时候被调用.
4.当定义一个类定义的时候,通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略不去Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的.而一般方法不存在这一特点
补充:
构造函数的名字必须与类名相同,而且不可以有返回值,也不能有return 语句。
构造函数往往执行一些初始化的操作。
析构函数(销毁一个对象)
1:析构函数与构造函数相反,构造函数用于构造一个对象,析构函数则用于在对象被销毁后清楚它所占用的内存空间,比如说它可以清除构造函数创建的内存。
2:析构函数是没有返回值的。
#include
<iostream>
#include
<conio.h>
using
namespace
std;
class
A
{
public
:
A()
{
cout<<
"构造函数执行完毕!\n"
;
}
~A()
//创建一个析构函数,析构函数没有返回值以及参数,并且一个类只有一个析构函数;
{
cout<<
"析构函数执行完毕!\n"
;
}
};
int
main()
{
A
a;
return
0;
}
构造一个对象数组
/*析构函数数组*/
#include
<iostream>
using
namespace
std;
class
A
{
public
:
A();
~A();
};
A
::A()
{
cout<<
"构造函数执行完毕"
<<endl;
}
A
::~A()
{
cout<<
"析构函数执行完毕"
<<endl;
}
int
main()
{
A
a[2];
//声明一个对象数组
return
0;
}
对象:是指能存储数据病具有某种类型的内存空间