c++的类和对象

面向对象的概念及特点：
将系统看成交互作用，完成特定功能对象的集合。每个对象用自己的方法管理数据。

特点：抽象，封装，继承，多态。
封装：限制属性和操作的访问权限，将属性隐藏在对象内部，对外提供一定的接口，在对象之外只能通过接口对对象操作。
多态性：同一消息被不同对象接收时，产生不同结果。实现同一接口不同方法。

A）封装，是面向对象程序设计最基本的特性。把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。
B）封装，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
备注：有2层含义（把属性和方法进行封装 对属性和方法进行访问控制）
C++中类的封装
成员变量，C++中用于表示类属性的变量
成员函数，C++中用于表示类行为的函数

比如求圆的面积
// 求圆的面积
struct circle
{
double m_r; // 圆的半径
double m_s; // 圆的面积
};

// C++中提供一个新的关键字 class, 用来定义类，使用方式和struct基本相同
// 但是增加一些其他的特性
// 类的封装：1、封装属性 2、封装方法
// 类的内部、类的外部
// 类的访问控制关键字：对属性和方法的使用权限进行限制
// public : 可以在类的内部和类的外部访问
// private : 可以在类的内部但不能在类的外部访问
// protect ：可以在类的内部访问，但不能在类的外部访问，用在继承里面
class Circle
{
public: // 类的成员访问权限，public 表示公开权限
double m_r; // 圆的半径，类的内部成员， 也叫属性
double m_s; // 圆的面积

public: // 类中不仅可以又成员变量，还可以有成员函数，用来定义类的一些操作方法
// 类的成员函数，设置类的半径
void setR(double r)
{
m_r = r;
}

// 获取圆的半径
double getR()
{
    return m_r;
}

// 获取圆的面积
double getS()
{
    m_s = 3.14 * m_r * m_r;
    return m_s;
}

};

void printCircle1(Circle c)
{
cout << c.getS() << endl;
}

void printCircle2(Circle& c)
{
cout << c.getS() << endl;
}

void printCircle3(Circle* c)
{
cout << c->getS() << endl;
}
int main()
{
Circle c1,c2; // 用类来定义变量 我们一般将这个变量叫对象

// 类的成员使用方式和结构体一样，对象使用 . 引用成员， 对象指针使用 -> 引用成员
c1.setR(10);  // 设置 对象 c1 的半径

// 打印圆的半径
cout << c1.m_r << endl;

// 调用成员函数获取圆的面积
cout << c1.getS() << endl;

printCircle1(c1);
printCircle2(c1);
printCircle3(&c1);
return 0;

}

在用struct定义类时，所有成员的默认属性为public
在用class定义类时，所有成员的默认属性为private
struct ClassA
{
int a; // 用 struct 关键字定义的类，不写，默认属性是public的
private:
int b;
};
类的声明放在头文件中:
class Student
{
public:
int getAge(); // 声明类的成员函数，函数在其他地方实现
void setAge(int age);

private:
char m_name[20];
int m_age;
};

类的实现放在源文件中：
#include “Student.h”

int Student::getAge()
{
return m_age;
}

void Student::setAge(int age)
{
m_age = age;
}

面对对象的案例:
圆形类
Circle.h文件：
#ifndef CIRCLE_H
#define CIRCLE_H
#include “MyPoint.h”

class Circle
{
public:
void setCircle(int r, int x, int y);
bool judge(MyPoint &p);

private:
int m_r;
int m_x;
int m_y;
};

#endif

Circle.cpp文件：
#include “Circle.h”

void Circle::setCircle(int r, int x, int y)
{
m_r = r;
m_x = x;
m_y = y;
}

bool Circle::judge(MyPoint &p)
{
int d = p.getX() * p.getX() + p.getY() * p.getY();
if (d <= m_r * m_r)
return true;
else
return false;
}

点类：
MyPoint.h文件：
#pragma once

class MyPoint
{
public:
void setXY(int x, int y);

int getX();
int getY();

private:
int m_x;
int m_y;
};
MyPoint.cpp文件
#include “MyPoint.h”
void MyPoint::setXY(int x, int y)
{
m_x = x;
m_y = y;
}

int MyPoint::getX()
{
return m_x;
}

int MyPoint::getY()
{
return m_y;
}
main.cpp文件
#include
#include “Circle.h”
#include “MyPoint.h”

int main()
{
Circle c;
c.setCircle(2,0,0);

MyPoint p;
p.setXY(2,1);

if (c.judge(p))
    std::cout << "点在圆内" << std::endl;
else
    std::cout << "点不在圆内" << std::endl;

return 0;

}

对象的构造和析构：
1）C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数；
2）构造函数在定义时可以有参数；
3）没有任何返回类型的声明。

1）C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
语法：~ClassName()
2）析构函数没有参数也没有任何返回类型的声明
3）析构函数在对象销毁时自动被调用

#include 
 
class Test
{
public:
    Test()   // 构造函数，构造函数与类名相同，没有返回值
    {
        std::cout << “我是构造函数，被调用了” << std::endl;
    }
 
    ~Test()  // 析构函数，析构函数与类名相同，前面有个~ 不能有返回值和参数
    {
        std::cout << “我是析构函数，被调用了” << std::endl;
    }
};
 
int main()
{
    // 类在创建对象的时候会自动调用构造函数
    Test t1;
    std::cout << “hello world” << std::endl;
 
    Test *t2 = new Test();
    std::cout << “1” << std::endl;
    delete t2;   // 对象在被销毁的时候会自动调用析构函数
    std::cout << “2” << std::endl;
 
    {
        Test t3;
    }
 
    std::cout << “3” << std::endl;
 
    return 0;
}