黑马程序员C++笔记---类和对象

c++中面向对象的三大特征：封装，继承，多态

c++认为万事万物都皆为对象，对象上有其特性和行为

具有相同性质的对象，我们可以抽象称之为类

4.1封装

意义：将属性和行为作为一个整体，表现生活中的事物

将属性和行为加以权限控制

意义一：在设计类的时候，属性和行为写在一起，表现事物

语法：class 类名{访问权限：属性/行为}；

#define PI 3.14

//设计一个圆，求圆的周长

//圆求周长的公式：2*PI*半径

//class +类名

class Circle

{

//访问权限

//公共权限

public:

//属性

//半径

int m_r;

//行为

//获取圆的周长

double calculateZC()

{

return 2 * PI * m_r;

}

};

int main()

{

//通过圆类创建具体的圆（对象）

Circle c1;

//给圆对象的属性赋值

c1.m_r = 10;

cout << "圆的周长为：" << c1.calculateZC() << endl;

/学生类

//class +类名

class Student

{

//访问权限

//公共权限

//类中的属性和行为  我们称为 成员

//属性   成员属性  成员变量

//行为  成员函数  成员方法

public:

//属性

//姓名

string m_name;

//学号

string m_num;

//

//行为

//获取圆的周长

string name()

{

return m_name;

}

string num()

{

return m_num;

}

//给姓名和学号赋值

void setname(string name)

{

m_name = name;

}

void setid(string id)

{

m_num= id;

}

};

int main()

{

//通过圆类创建具体的圆（对象)  实例化对象

Student c1;

//给圆对象的属性赋值

//c1.m_name = "张三";

c1.setname("张三");

//c1.m_num = "202134310103";

c1.setid( "202134310103");

cout << "学生的姓名为：" << c1.name() << endl;

cout << "学生的学号为" << c1.num()<< endl;

封装意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制

三种访问权限：

1.public      公共权限    成员类内可以访问，类外也可

2.protected    保护权限   类内可类外不可

3.private    私有权限    类内可   类外不可//最后两项在继承有所不同

class person

{

public:

//公共权限

string m_name;

protected:

//保护权限

string m_car;

private:

//私有权限

int m_password;//银行卡密码

public:

void func()

{

m_name = "张三";

m_car = "拖拉机";

m_password = 123456;

}

};

int main()

{

person p1;

p1.m_name = "李四";

struct 和class区别

在c++中struct和class唯一的区别就在于默认的访问权限不同

区别：

struct默认权限为公共

class默认权限为私有

class C1

{

int m_a;

};

struct C2

{

int m_a;

};

int main()

{

C1 c1;

c1.m_a=10;//错误

C2 c2;

c2.m_a = 10;//正确

成员属性设置为私有

优点一：将所有成员属性设置为私有，可以自己控制读写权限

优点二：对于写权限，我们可以检测数据的有效性

class person

{

public:

//设置姓名

void setname(string name)

{

m_name = name;

}

//获取姓名

string getname()

{

return m_name;

}

int getage()

{

//m_age = 0;//没有写入，要初始化  如果想要修改  年龄的范围必须是0~150之间，否则就初始化

return m_age;

}

void setage(int age)

{

if (age < 0 || age>150)

{

m_age = 0;

return;

}

m_age = age;

}

void setlover(string lover)

{

m_lover = lover;

}

private:

string m_name;//可读可写

int m_age;

string m_lover;

};

int main()

{

person p1;

p1.setname("张三");

p1.setage(18);

cout << "姓名为：" << p1.getname() << endl;

cout << "年龄为：" << p1.getage() << endl;

p1.setlover("苍井");

案例1：设计立方体类

Cube

求面积体积

分别用全局函数和成员函数判断两个立方体是否相等

//立方体

class cube

{

public:

//行为

//设置获取长宽高

void setl(int l)

{

   m_l = l;

}

int getl()

{

return m_l;

}

void setw(int w)

{

m_w = w;

}

int getw()

{

return m_w;

}

void seth(int h)

{

m_h = h;

}

int geth()

{

return m_h;

}

//获取面积

int calculates()

{

return 2 * m_l * m_w + 2 * m_l * m_h + 2 * m_h * m_w;

}

//获取体积

int calculatev()

{

return m_w * m_h * m_l;

}

bool issamebyclass(cube &c)//在类里面，已知一个成员函数，只需传入另一个与之比较

{

if (m_l == c.getl() && m_w == c.getw() && m_h == c.geth())

{

return true;

}

return false;

}

private:

//属性

int m_l;

int m_h;

int m_w;

};

//利用全局函数判断  两个立方体是否相等

bool issame(cube &c1,cube &c2)

{

if (c1.getl() == c2.getl() && c1.getw() == c2.getw() && c1.geth() == c2.geth())

{

return true;

}

return false;

}

int main()

{

cube c1;

c1.setl(10);

c1.setw(10);

c1.seth(10);

cout << "面积" << c1.calculates() << endl;

cout << "体积" << c1.calculatev() << endl;

cube c2;

c2.setl(10);

c2.setw(10);

c2.seth(11);

bool ret = issame(c1, c2);

if (ret)

{

cout << "c1和c2是相等的" << endl;

}

else

{

cout << "c1和c2不相等" << endl;

}

ret = c1.issamebyclass(c2);

if (ret)

{

cout << "成：c1和c2是相等的" << endl;

}

else

{

cout << "成：c1和c2不相等" << endl;

}

点和圆案例

源cpp

#include<iostream>

#include "string"

using namespace std;

/*class point

{

public:

void setx(int x)

{

m_x = x;

}

int getx()

{

return m_x;

}

void sety(int y)

{

m_y = y;

}

int gety()

{

return m_y;

}

private:

int m_x;

int m_y;

};*/

class circle

{

public:

void setr(int r)

{

m_r = r;

}

int getr()

{

return m_r;

}

void setcenter(point center)

{

m_center = center;

}

point getcenter()

{

return m_center;

}

private:

//在类中可以让另一个类  作为本来中的成员

int m_r;

point m_center;

};

void isincircle(circle &c,point &p)

{

int distance = (c.getcenter().getx() - p.getx()) * (c.getcenter().getx() - p.getx()) + (c.getcenter().gety() - p.gety()) * (c.getcenter().gety() - p.gety());

int rdistance = c.getr() * c.getr();

if (distance == rdistance)

{

cout << "点在圆上" << endl;

}

else if(distance>rdistance)

{

cout << "点在圆外" << endl;

}

else

{

cout << "点在圆内" << endl;

}

}

int main()

{

circle c;

c.setr(10);

point center;

center.setx(10);

center.sety(0);

c.setcenter(center);

point p;

p.setx(10);

p.sety(10);

isincircle(c, p);

    system("pause");

return 0;

}

point.h

#pragma once

#include<iostream>

using namespace std;

class point

{

public:

void setx(int x);

int getx();

void sety(int y);

int gety();

private:

int m_x;

int m_y;

};

point.cpp

#include "point.h"

void point::setx(int x)

{

m_x = x;

}

int point::getx()

{

return m_x;

}

void point::sety(int y)

{

m_y = y;

}

int point::gety()

{

return m_y;

}