12 - 类和对象

类和对象基本概念

1）类、对象、成员变量、成员函数

2）面向对象三大概念：封装、继承、多态

封装（Encapsulation）

封装是面向对象程序设计最基本的特性。把数据（属性）和函数（操作）合成一个整体。把客观的事物抽象成类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏（把属性和方法进行封装，对属性和方法进行访问控制）。

C++中类的封装：成员变量，C++中用于表示类属性的变量；成员函数，C++中用于表示类行为的函数。

在C++当中可以给成员变量和成员函数定义访问级别，Public修饰的成员变量和成员函数可以在类的内部和类的外部进行访问。Private修饰的成员变量和成员函数只能在类的内部被访问。

在使用struct定义类时，所有的成员的默认属性为public。在使用class定义类时，所有的成员默认的属性为private。我们常使用class定义类。

对象的构造和析构

创建一个对象时，经常需要某些初始化工作，为了解决这个问题，C++编译器提供了构造函数来处理对象的初始化。构造函数是一种特殊的成员函数，与其他的成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。

构造函数和析构函数的概念

构造函数

在C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数被叫做构造函数。构造函数在定义时可以有参数，但是构造函数没有任何返回类型的声明。

构造函数一般情况下是C++编译器自动调用，但是在某些情况还是需要手动调用构造函数。

析构函数

C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数。析构函数没有参数也没有任何返回类型的声明，析构函数在对象销毁时自动被调用。

class hero
{
public:
    hero();    //构造函数
    ~hero();   //析构函数
};

设计构造函数和析构函数的原因

面向对象的思想是从生活中来的，生活中存在的对象都是被初始化之后才上市的。初始状态是对象普遍存在的一个状态。

那么可能有人会说，那我自己写好啦，不需要你这个啊。

首先，你所写的只是一个普通的函数，必须显式的调用，如果是定义一个对象数组，根本就没有机会进行显式初始化。而且一旦由于某种失误对象没有初始化，那么结果是不确定的。没有初始化的对象，其内部的成员变量的值时不定的。而且不能完全的解决问题。

构造函数的分类以及调用

//有参数构造函数的三种调用方法
class Test
{
private:
    int a;
    int b;

public:
    //无参数构造函数
    Test()
    {
        ;
    }
	
    //带参数的构造函数
    Test(int a, int b)
    {
        ;
    }

    //赋值构造函数
    Test(const Test &obj)
    {
        ;
    }

public:
    void init(int _a, int _b)
    {
        a = _a;
        b = _b;
    }
}

无参构造函数调用方法

Test t1,t2;

有参构造函数三种调用方法

//有参数构造函数的三种调用方法
class Test
{
private:
    int a;

public:
    //带参数的构造函数
    Test(int a)
    {
        printf("na:%d", a);
    }

    Test(int a, int b)
    {
        printf("na:%d b:%d", a, b);
    }
};

int main()
{
    Test t1(10);        //c++编译器默认调用有参构造函数 括号法 
    Test t2 = (20, 10); //c++编译器默认调用有参构造函数 等号法
    Test t3 = Test(30); //程序员手工调用构造函数 产生了一个对象 直接调用构造构造函数法

    system("pause");
    return 0;
}

拷贝构造函数调用的四种场景

/*
    第一个调用场景
*/
#include "iostream"
using namespace std;

class A
{
public:
    A() //无参构造函数 默认构造函数
    {
        cout << "我是构造函数，自动被调用了" << endl;
    }
    A(int _a) //无参构造函数 默认构造函数
    {
        a = _a;
    }
    A(const A& obj2)
    {
        cout << "我也是构造函数，我是通过另外一个对象obj2，来初始化我自己" << endl;
        a = obj2.a + 10;
    }
    ~A()
    {
        cout << "我是析构函数，自动被调用了" << endl;
    }
    void getA()
    {
        printf("a:%d n", a);
    }

private:
    int a;
};

int main()
{
    A a1; //变量定义

    //赋值构造函数的第一个应用场景
    //用对象1 初始化 对象2 
    A a2 = a1; //定义变量并初始化 //初始化法

    a2 = a1; //用a1来=号给a2 编译器给我们提供的浅copy
}

/*
    第二个调用场景
*/
#include "iostream"
using namespace std;

class A
{
public:
    A() //无参构造函数 默认构造函数
    {
        cout << "我是构造函数，自动被调用了" << endl;
    }
    A(int _a) //无参构造函数 默认构造函数
    {
        a = _a;
    }
    A(const A& obj2)
    {
        cout << "我也是构造函数，我是通过另外一个对象obj2，来初始化我自己" << endl;
        a = obj2.a + 10;
    }
    ~A()
    {
        cout << "我是析构函数，自动被调用了" << endl;
    }
    void getA()
    {
        printf("a:%d n", a);
    }

private:
    int a;
};

int main()
{
    A a1(10); //变量定义

    //赋值构造函数的第一个应用场景
    //用对象1 初始化 对象2 
    A a2(a1); //定义变量并初始化 //括号法

    //a2 = a1; //用a1来=号给a2 编译器给我们提供的浅copy
    a2.getA();
} 
//注意：初始化操作 和 等号操作 是两个不同的概念

/*
    第三个调用场景
*/
#include "iostream"
using namespace std;

class Location
{
public:
    Location(int xx = 0, int yy = 0)
    {
        X = xx;  Y = yy;  cout << "Constructor Object.n";
    }

    Location(const Location& p) 	    //复制构造函数
    {
        X = p.X;  Y = p.Y;   cout << "Copy_constructor called." << endl;
    }

    ~Location()
    {
        cout << X << "," << Y << " Object destroyed." << endl;
    }

    int GetX() { return X; }
    int GetY() { return Y; }

private:   
    int X, Y;
};

void f(Location  p)
{
    cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl;
}

void mainobjplay()
{
    Location A(1, 2);  //形参是一个元素，函数调用，会执行实参变量初始化形参变量
    f(A);
}

void main()
{
    mainobjplay();
    system("pause");
}

/*
    第四个调用场景
*/
#include "iostream"

using namespace std;

class Location 
{ 
public:
    Location( int x = 0 , int y = 0 ) 
    { 
        X = x ;  Y = y ;  cout << "Constructor Object.n" ; 
    }

    Location( const Location & p ) 	    //复制构造函数
    { 
        X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;  
    }

    ~Location() 
    { 
        cout << X << "," << Y << " Object destroyed." << endl ; 
    }

    int GetX () { return X ; }
    int GetY () { return Y ; }

private:
    int X , Y ;
} ;


void f ( Location  p )   
{ 
    cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ; 
}

Location g()
{
    Location A(1, 2);
    return A;
}

//对象初始化操作 和 =等号操作 是两个不同的概念
//匿名对象的去和留，关键看，返回时如何接
void mainobjplay()
{  
    //若返回的匿名对象，赋值给另外一个同类型的对象，那么匿名对象会被析构
    //Location B;
    //B = g();  //用匿名对象 赋值 给B对象，然后匿名对象析构

    //若返回的匿名对象，来初始化另外一个同类型的对象，那么匿名对象会直接转成新的对象
    Location B = g();
    cout<<"传智扫地僧测试"<<endl;
} 

void main()
{  
    mainobjplay();
    system("pause");
}

默认构造函数

当类中没有定义构造函数时，编译器会自动提供一个无参的构造函数，其函数体为空。

当类中没有定义拷贝构造函数时，编译器默认提供一个默认拷贝构造函数，简单的进行成员变量的值复制。

构造函数调用规则

当类中没有定义任何一个构造函数时，C++编译器会自动提供默认的无参构造函数和默认拷贝构造函数。

当类中定义了拷贝构造函数时，C++编译器不会提供默认无参数构造函数。

当类中定义了任意的非拷贝构造函数（有参构造函数或者无参构造函数），C++编译器都不会提供默认无参构造函数。

默认拷贝构造函数是成员变量简单的赋值。

构造函数是C++中用于初始化对象状态的特殊函数，在对象创建时被自动调用，是对象正确初始化的重要保证。

构造函数和普通函数都遵循重载规则，必要的时候，必须手工编写拷贝构造函数。

深拷贝和浅拷贝

默认复制构造函数可以完成对象的数据成员值的简单复制。

对象的数据资源是由指针指向的堆，默认复制构造函数仅做指针值复制。

浅拷贝出现的原因

默认提供的浅拷贝是传递了一个指向的内存空间，即两个指针同时指向一个内存空间，那么这会产生一个问题，如果一个指针对内存空间进行了释放，那么另一个指针就成为了野指针。

浅拷贝的解决方法

所谓深拷贝，把内部的数据都传递给另一个对象。

这就像是，你看见我在吃糖，你也想吃，你就问我能不能把糖给你吃呢。浅拷贝就是咱俩吃这一块糖，一起吃，吃没了那就都没了。深拷贝就像是，我给你了一块糖，咱俩一人一块糖。你吃没了那就是你自己的没有了，我的还在，不存在相互影响。

需要注意的是如何进行深拷贝，我想给你一块糖，那你是不是要有地方放，换句话说，我给你好多好多糖，还有不同的各种品种，是不是需要对每种类型的糖进行划分，然后分别存放。

//拷贝构造函数
Array::Array(const Array& obj)
{
	this->m_length = obj.m_length;        //我有多少我就给你一样多的糖
	this->m_space = new int[m_length];    //我的糖需要这么大的地方放，那你肯定也是
	
	for (int i = 0; i < m_length; i++)    //我把糖一个个的装好了，然后给你。
	{
		this->m_space[i] = obj.m_space[i];
	}
}
//这是我写的一个数组类，因为内部只有这些数据成员，如果内部数据成员多的话，那么可以按照这个思路继续往下写。

多个对象构造和析构

对象初始化列表

如果我们有一个类成员，它本身是一个类或者结构，而且这个成员它只有一个带参数的构造函数而没有默认构造函数。这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数。

如果没有初始化列表，它将无法完成初始化，就会报错。

类成员当中如果有const修饰，必须在对象初始化时，对const进行初始化。

因为这两种对象要在声明之后马上初始化，而在构造函数当中，做的是对他们的赋值，这样是不被允许的。

//语法规则
Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
{
    // some other assignment operation
}

成员变量的初始化顺序与声明的顺序有关，与在初始化列表中的顺序无关。初始化列表先于构造函数的函数体执行。

当类中有成员变量或者是其他类的对象时，首先调用成员变量的构造函数，调用顺序与声明顺序相同，之后调用自身了IDE构造函数。

析构函数的调用顺序与对应的构造函数调用顺序相反。

对象的动态建立和释放

new和delete基本语法

在软件开发过程当中，经常需要动态的分配和释放内存。在C语言中是利用库函数malloc和free来分配和释放空间。C++中提供了简便而功能更强的运算符new和delete对库函数malloc和free进行取代。

需要注意，new和delete是运算符，因此执行的效率更高。

虽然为了与C兼容，C++仍然保留malloc和free函数，但是并不建议是使用。因为在初始化对象时，new和delete会调用类对象的构造函数和析构函数。

new int;           //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)
new int(100);      //开辟一个存放整数的空间，并指定该整数的初值为100，返回一个指向该存储空间的地址
new char[10];      //开辟一个存放字符数组(包括10个元素)的空间，返回首元素的地址
new int[5][4];     //开辟一个存放二维整型数组(大小为5*4)的空间，返回首元素的地址

//开辟一个存放单精度数的空间，并指定该实数的初值为3.14159，将返回的该空间的地址赋给指针变量p
float *p=new float (3.14159);  

new分配数组空间时，不能指定初值。如果由于内存不足的原因而无法正常的分配空间，new会返回一个空指针NULL，用户可以根据该指针的值判断空间是否成功分配。

类对象的动态建立和释放

使用类名定义的对象都是静态的，在程序运行过程当中，对象所占的空间是不能随时释放的。但是有时人们希望在需要用到对象的时候才建立对象，在不需要对象时就撤销它，释放它所占用的内存空间以供别的数据使用。这样可以提高内存空间的利用效率。

C++当中，可以使用new运算符动态建立对象，用delete运算符撤销对象。

Box *pt;     //定义一个指向Box类对象的指针变量pt

pt = new Box;  //在pt中存放了新建对象的起始地址

//在程序中就可以通过pt访问这个新建的对象
cout << pt->height;     //输出该对象的height成员

cout << pt->volume( );  //调用该对象的volume函数，计算并输出体积

//C++还允许在执行new时，对新建立的对象进行初始化。
Box *pt = new Box(12,15,18);

//这种写法是把上面两个语句(定义指针变量和用new建立新对象)合并为一个语句，并指定初值。这样更精炼。 
//新对象中的height，width和length分别获得初值12,15,18。调用对象既可以通过对象名，也可以通过指针。

在执行new运算时，如果内存容量不足，无法开辟所需要的内存空间，目前大多数C++编译器系统都会让new返回一个0指针值。只要检测返回值是否为0，就可以判断内存是否开辟成功。

ANSI C++标准提出，在执行new出现故障时，就抛出一个异常，用户可以根据异常进行有关处理。但是C++标准仍然允许在出现new故障时返回0指针值。当前，不同的编译系统对new故障的处理方法是不同的。

在不再需要使用由new建立的对象时，可以用delete运算符予以释放。

delete pt; //释放pt指向的内存空间

这就撤销了pt指向的对象，此后程序不能再使用该对象。

如果用一个指针变量pt先后指向不同的动态对象，应该注意指针变量的当前指向，以免删错了对象。在执行delete运算符时，在释放内存空间之前，自动调用析构函数，完成有关的善后清理工作。

静态成员变量成员函数

静态成员变量

关键字static可以用于说明一个类的成员，静态成员提供了一个同类对象的共享机制。把一个类的成员说明为static时，这个类无论有多少个对象被创建，这些对象共享这个static成员。静态成员局部与类，它不是对象成员。

#include<iostream.h>

class  counter
{ 
public :
    counter (int a) { mem = a; }
    int mem;		//公有数据成员
    static  int  Smem ;	//公有静态数据成员
};

int  counter :: Smem = 1 ;	//初始值为1 使用静态成员时，需要在使用前进行定义

int main()
{   
    counter c(5);
    int i ;

    for( i = 0 ; i < 5 ; i ++ )
    { 
        counter::Smem += i ;
        cout << counter::Smem << 't' ;  //访问静态成员变量方法2
    }

    cout<<endl;
    cout<<"c.Smem = "<<c.Smem<<endl; //访问静态成员变量方法1
    cout<<"c.mem = "<<c.mem<<endl;
}

静态成员函数

静态成员函数同样使用关键字static，静态成员提供不依赖于类数据结构的共同操作，它没有this指针。在类外调用静态成员函数需要使用“类名::”作限定词，或者通过对象调用。

C++面向对象模型初探

语言中直接支持面向对象程序设计的部分，主要涉及如构造函数、析构函数、虚函数、继承（单继承、多继承、虚继承）、多态等等。

在C语言当中，“数据”和“处理数据的操作（函数）”是分开来声明的，也就是说，语言本身并没有支持“数据和函数”之间的关联性。在C++当中，通过抽象数据类型，在类当中定义数据和函数，来实现数据和函数直接的绑定。

概括的来说，在C++类中有两种成员数据：static、nonstatic；三种成员函数：static、nonstatic、virtual。

C++中的Class从面向对象理论出发，将变量和函数集中定义在一起，用于描述现实世界中的类。从计算机的角度，程序依然由数据段和代码段构成。

C++类对象中的成员变量和成员函数是分开存储的。

普通成员变量：存储在对象当中，与struct变量有相同的内存布局和字节对齐方式。

静态成员变量：存储在全局数据区中。

成员函数：存储在代码段中。

C++中类的普通成员函数都隐式包含一个指向当前对象的this指针，这就是为什么很多对象共用一块代码，编译器还能区分代码是哪个具体对象的。

静态成员函数、成员变量属于类。静态成员函数和普通成员函数的区别就在于，静态函数不包含指向具体对象的指针，普通成员包含一个指向具体对象的指针。

this指针

全局函数 PK 成员函数

//把全局函数转化成成员函数，通过this指针隐藏左操作数
Test add(Test &t1, Test &t2) ===》Test add(Test &t2)

//把成员函数转换成全局函数，多了一个参数
void printAB() ===》void printAB(Test *pthis)

//函数返回元素和返回引用
Test& add(Test &t2) //*this //函数返回引用
{
    this->a = this->a + t2.getA();
    this->b = this->b + t2.getB();
    return *this; //*操作让this指针回到元素状态
} 

Test add2(Test &t2) //*this //函数返回元素
{
    //t3是局部变量
    Test t3(this->a+t2.getA(), this->b + t2.getB()) ;
    return t3;
}

友元

友元函数

友元函数使用friend进行修饰，说明语句位置与访问描述无关。友元函数可以通过对象参数访问私有数据成员。友元函数大部分都被使用在运算符重载。

友元类

如果B类是A类的友元类，则B类的所有成员函数都是A类的友元函数。友元类通常设计为一种数据操作或者类之间传递消息的辅助类。

最后

以上就是勤恳啤酒为你收集整理的12 - 类和对象的全部内容，希望文章能够帮你解决12 - 类和对象所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。