c++类与对象

  一.类与对象的概念

1.面向对象是指一种程序设计范型，同时也是一种程序开发的方法。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。
面向对象: 利用对象间的消息传递来驱动程序的执行。

优点: 真实表现客观世界,对象间的关系清晰，对象间的消息处理高效。

面向过程: 强调处理问题的过程。
不足之处: 复用性较差，无法真实描绘客观世界。

2、类和对象的定义:
对象是对问题域中客观存在的事物的抽象，它是一组属性和这些属性上的操作的封装体。
类是具有相同属性和操作的一组对象的统一抽象的描述。
类是对象的模板，
对象是类的实体。

对象=数据+数据上的操作
程序= (对象1+对象2+对象3+...) + 消息
消息:
面向对象中，我们称一个对象对另一个对象施加的操作为消息(message)。
如: 对汽车对象，点火、换档、踩油门、踩刹车等，这些施加
操作的过程，称为发送消息。

对象具有抽象性、封装性、继承性、多态性四个特点。

(1) 对象的抽象性
抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。程序设计中对象的抽象有两方面，一是对数据的抽象，即是对象本身属性的抽象
。二是过程的抽象，即是对象本身行为的抽象。
(2) 对象的封装性

封装有两个含义:
一是把对象的全部属性和操作结合在一起，形成一个不可分割的整体对象

二是信息隐藏，即这个整体对外尽量隐藏它的细节，只公布一个有限界面，
通过这个界面和其它对象交互。
(3) 对象的继承性
特殊类的对象获得一般类的全部属性与称做特殊类对一般类的继承
被继承的类叫父类或基类，继承父类的类叫子类或派生类。

例：圆形（circle)的数据抽象：

int x, y;                                                                                    class circle

double  r;                        抽象                                                  {

行为抽象：————————————————>                  public:

                                                                                                     void  setx(int  m) {x=m;}

setx();  sety();  setr();  draw();                                                        void  sety(int  n) {y=n;}

                                                                                                     void  set(int  k)  {y=k;}

                                                                                                     void  draw() {.....}

                                                                                               private:

                                                                                                    int  x,y;

                                                                                                    double  r;

                                                                                                  };

二、类和对象的定义
1、类定义形式:
class 类名
{ public:     //公有段数据成员和成员函数;

 

protected:     //保护段数据成员和成员函数;

private:      //私有段数据成员和成员函数;
};

访问控制修饰符                     访问控制作用

public ————————————  在程序的任何地方

都可以访问类public成员

private ————————————只能类内部和友元中访问

protected ——————————只能在本类、派生类和友元中访问

例  定义一个类
class sample

{
private int x;
public:
void fun()
  {.......;

}
};

例   定义一个类(类外实现成员函数)
class sample

{
private int x;
public:
void fun();
};

void sample::.fun()

{
.......;

}          //类外成员函数的实现

类外函数实现的格式为:
函数类型    类名::函数名(参数表)
             {语句组;}
其中，运算符“:：”称为作用域分辨符，它指出“函数名”是属于“类名”的成员函数。

2、定义对象:
方法1:
class A

{
public:
int r,t;

}；

方法2 :
class B

{
int I,j;
public:
void Setdata(int a,int b)
{l=a; j=b;};
void print(void)
{cout<<lk<<'\t'<<j<<'\n';}
};

3、类中的构造函数:
(1)构造函数是类的成员函数，在类内声明，可以在类体内或类体外实现。
(2)构造函数名与类名相同。
(3)构造函数无返回值。
(4)构造函数在创建对象时，自动调用，不需要程序员写代码显式调用。

例:
#include<iostream>
class test

{
public:
test()

{cout <<"c called \n";}
};
test obj1;
int main()
{test obj1;}
输出结果为:
c called

构造函数的重载:
例:
#include<iostream>
class test

{
public:
test(){cout<<" c called \n";}

test(char *name){cout<<"c called  name="<<name;}
};
test obj1;
int main()

{
test obj1;
text obj2 ("小明");

}
输出结果为: c called
            c called name=小明

4、类中的析构函数
(1)析构函数名为“ ~<类名>”。如，Calendar类的析构函数名为  ~Calendar.
(2)没有参数和返回值。
(3)析构函数不能重载。
(4)当对象消亡时，系统回收该对象所占用的内存空间前，析构函数会被自动调用。

5、类使用的几点说明:
  (1) 在类的外部，只能访问类的公有成员，而不能访问类的私有成员或保护成员。若要访问类对象的私有成员，只能通过对象的公有成员函数来获取。
  (2) 同类型的对象之间可以整体赋值，例如:rr=r,将对象r的所有成员依次赋给对象rr的成员，这种赋值与对象的成员访问权限无关。
  (3) 对象用作函数的参数时，属于赋值调用; 函数也可以返回一个对象。

需要现实引用this指针的三种情况

（1） 在类的非静态成员函数中返回类对象本身或对象的引用的时候，

       直接使用return *this, 返回本对象的地址时，用return this。

（2）当参数与成员变量名相同时，如  this - > x=x, 不能写成x=x.

（3）避免对同一对象进行赋值操作，判断两个对象是否相同时，使用this指针。

      1.例：

函数返回对象的引用
#include <iostream>
#include <string>
using namespace std;
class Person

{
public:
Person(string n, int a)

{
name=n; ————————————————//这里的name等价于this->name
age=a;  ————————————————  //这里的age等价于this->age
int get_age(void)const   { return age;}
Person& add_age (int i)   {age + i; retum *this;}
private
string name;
int age;

};

int main()

{
Person Li( "Li", 20);
cout <<" Li age ="< Li.get_age()<<endl;
cout<<" Li add age "=<< Li. add_age(1).get_ageo<<endl;
           //增加1岁的同时,可以对新的年龄直接输出
return 0;

}
程序执行结果为:
Li age= 20
Li add age= 21
   2.例

#include <iostream>
using namespace std;
class Point

{
public：
int x;
Point () : x(0) {  }
Point(int a) {x=a: }
void print ()  { cout <<" x="<<x<<endl;} 
void set_x(nt×) { x=x;}

};
int main()

{

Point pt(5);

pt.set_x(10);

pt.print();

return 0;

}

程序执行结果为：    x=5

若将set_x函数改为;   void set_x(int x) { this->x=x;}

执行结果为：     x=10

心得：一部分心得在上文中已有体现，但还有需要注意的地方，对象不要定义为全局变量（函数除外），构造函数一般要定义两个以上，包括不带参函数。类与对象在初学的时候就有模糊的接触，只是当时不怎么理解，照搬者居多，学到这里也只能说理解了是怎么回事，运用还需加强。