c++类.封装 对象特性

属性 + 行为

一、

1、作比较：

class Cube
{
    bool issame(Cube& c);
};
int main()
{
    ...
    Cube c1,c2;
    c1.issame(c2);
}

2、套娃（类中可以让另一个类作为其成员）

class Point
{
	int m_X, m_Y;
    ....
};
class Circle
{
	int m_R;
	Point m_center; //***
    ....
};

要引用时：c. getcenter() . getx()

3、将类分开到不同文件中

1）建立一个头文件：声明这个类

#pragma once
#include<iostream>;
class Point
{
	int m_X, m_Y;
public:
	void setxy(int& x, int& y);
	int getx();
	int gety();
};

2）建立一个源文件：实现成员函数

#include<iostream>;
#include"point.h"
void Point::setxy(int& x, int& y)
{
	m_X = x;
	m_Y = y;
}
int Point::getx()
{
	return m_X;
}
int Point::gety()
{
	return m_Y;
}

注意：1、要带头文件#include"point.h" 2、要用 :: 运算符进行访问

3）主函数也要带上#include"point.h"

二、构造函数和析构函数（对象的初始化和清理）

构造：类名( ){ }

1、在调用对象时(Person p)自动调用  2、可以有参数所以可以发生重载 3、无返回值不加void

析构：~类名( ){ }

1、在销毁对象是自动调用  2、不可以有参数  3、无返回值不加void

class Person
{
    int age;
public:
	Person()
	{
		//构造函数
	}
	~Person()
	{
		//析构函数
	}
};

分类：

Person ()
{
    //普通构造函数/无参
};
Person (int a)
{
    age = a;
    //有参构造函数
};
Perspm (const &p1)
{
    age = p1.age;
    //拷贝构造函数
};

调用：

括号法

Person p1; //默认构造函数调用，不能加（）因为可能被编译器认为是函数声明
Person p2(10);  //有参
Person p3(p2);  //拷贝

显示法：

Person p1;
Person p2 = Person(10);
Person p3 = Persom(p1);
//Person (10)是一个匿名对象

隐式转换法：

Person p1 = 10; ( == Person p1 = Person (10)  )

初始化列表

传统：

class Person
{
	int m_1, m_2, m_3;
public:
	Person(int a, int b, int c)
	{
		m_1 = a; m_2 = b; m_3 = c;
	}
};
int main()
{
	Person p(10, 20, 30);
	return 0;
}

可以替换为：

Person(int a, int b, int c) :m_1(a), m_2(b), m_3(c){}

类对象作为类成员：

当其它类对象作为本类成员，构造函数先构造其他类再本身；析构函数则相反

this指针：

this指针不需要定义，直接使用，它是隐含在每一个成员函数内的一个指针。this指针指向被调成员函数所属的对象。本质是指针常量，Person * const this，不可以修改this的指向

1、解决名称冲突：

2、返回对象本身：return *this；

class Person
{
    Person& addperson(Person &p)
    {
        m_age+=p.m_age;
        return *this;
};
int main()
{
    ...
    Person p1(10);
    Person p2(10);
    p2.addperson(p1); //return的就是p2
    

静态成员：

静态成员变量：1、所有对象共享同一份数据（所以既可以通过对象访问，也可以通过类名访问。

                          2、在编译阶段分配内存   3、类内声名，类外初始化

静态成员函数：1、所有对象共享同一个函数

                          2、静态成员函数只能访问静态成员。

静态数据成员要在类外初始化

数据类型 类名：：成员属性 = 值