c++类&对象：
类中的数据和方法称为类的成员，例如函数在一个类中被称为类的成员。
类的定义：
类的定义是以关键字class开头，后跟类的名称。类的主体是包含在一对花括号中；关键字public确定了成员的访问属性，在类作用对象域内，公共成员在类的外部是可访问的，类的成员访问属性还可为private或protected。
说明：
1.公共权限 public 成员类内可以访问 类外也可以访问；
2.保护权限 protected 成员类内可以访问 类外不可以访问 ；子类可以访问父类中的保护内容（继承）
3.私有权限 private 成员类内可以访问 类外不可以访问 ；子类不可以访问父类中的私有内容（继承）
4.class和struct的区别：默认权限不同，calss默认的是私有权限，而public默认的是公共权限；
类对象：声明类的对象，就像声明基本类型的变量一样。
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
访问数据成员：类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问
#include <iostream>
using namespace std;//iostream是指iostream库。iostream的意思是输入输出流，直接点说就是in（输入） out（输出） stream（流），取in、out的首字母与stream合成
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
// 成员函数声明
double get(void);
void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void) //“::”作用域限定符
{
return length * breadth * height;
}
void Box::set( double len, double bre, double hei)
{
length = len;
breadth = bre;
height = hei;
}
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
Box Box3; // 声明 Box3，类型为 Box
double volume = 0.0; // 用于存储体积
// box 1 详述
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 详述
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// box 1 的体积
volume = Box1.height * Box1.length * Box1.breadth;
cout << "Box1 的体积：" << volume <<endl;//endl=endline
// box 2 的体积
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Box2 的体积：" << volume <<endl;
// box 3 详述
Box3.set(16.0, 8.0, 12.0);
volume = Box3.get();
cout << "Box3 的体积：" << volume <<endl;
return 0;
}运行结果：
Box1 的体积：210
Box2 的体积：1560
Box3 的体积：1536说明：1.私有成员和受保护的成员不能使用直接成员访问运算符（.）来直接访问。“::”作用域限定符
用作用域限定符声明函数是那个类的，在作用域运算符的前面没有类名，或者函数名前面既无类名又无作用域限定符，则表示函数不属于任何类，这个函数不是成员函数，是全局函数。
2.C++在类体中直接定义函数时，不需要在函数名前面加上类名，但成员函数在类外定义时，必须在函数名前面加上类名；
3.类函数必须先在类体中作原形声明，然后在类外面定义，类体的位置应在函数定义之前；
以下是练习案例：
1
#include<iostream>
using namespace std;
const double PI=3.14;
//设计一个圆类，求周长？
class Circle
{
//访问权限
public:
//属性
int r;//半径
//行为 （获取圆的周长）
double calculateZC()
{
return 2*PI*r;
}
};
int main()
{
//通过圆类来具体创建圆(对象)，实例化。
Circle c1;
c1.r=2;
cout<<"圆的周长为："<<c1.calculateZC()<<endl;
system("pause");
return 0;
}运行结果：
圆的周长为：12.56
请按任意键继续. . .
2.
//设计一个学生类，属性有学号和姓名，可以赋值和显示；
#include<iostream>
using namespace std;
class Student
{
//访问权限
public:
//属性
int stu_id;
string name;
//行为 添加并获取学生信息
void ShowStudent()
{
cout<<"学号："<<stu_id<<"姓名:"<<name<<endl;
}
void setStu_id(int id)
{
stu_id=id;
}
};
int main()
{
//实例化 1
Student s1;
s1.stu_id =19;
s1.name="xiaoming";
s1.ShowStudent();
//2
Student s2;
s2.name="xiaoxiao";
s2.setStu_id(18);
// s2.stu_id =18;
s2.ShowStudent();
system("pause");
return 0;
}运行结果：
学号：19姓名:xiaoming
学号：18姓名:xiaoxiao
请按任意键继续. . .C++继承：继承允许依据另一个类来定义一个类
当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可，称为基类，新建的类称为派生类 如；（狗即具有动物的共性，又有自身特性）。如图：
继承的好处：可以减少代码的重复
派生类的成员，包含两部分：
一类是从基类继承过来的，一类是自己添加的成员。
从基类继承过来的表现共性，而新增的成员表现为其个性。
练习案例：
#include<iostream>
using namespace std;
class Basepage
{
//访问权限
public:
//属性
//行为
void header()
{
cout<<"首页、公开课、登录、注册....（公共头部）"<<endl;
}
void footer()
{
cout<<"帮助中心、交流合作、站内地图...(公共底部)"<<endl;
}
void left()
{
cout<<"java、c++、python...（公共分类）"<<endl;
}
};
//class Python
//{
访问权限
//public:
// void header()
// {
// cout<<"首页、公开课、登录、注册....（公共头部）"<<endl;
//
// }
// void footer()
// {
// cout<<"帮助中心、交流合作、站内地图...(公共底部)"<<endl;
//
// }
// void left()
// {
// cout<<"java、c++、python...（公共分类）"<<endl;
// }
// void content()
// {
// cout<<"Python的视频"<<endl;
// }
//};
class Python:public Basepage
{
public:
void content()
{
cout<<"python学科视频"<<endl;
}
};
void Showpassage()
{
// //实例化
// cout<<"这是Java页面"<<endl;
// Java ja;
// ja.header();
// ja.footer();
// ja.left();
// ja.content();
cout<<"这是python的页面"<<endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
}
int main()
{
Showpassage();
return 0;
}运行结果：
这是python的页面
首页、公开课、登录、注册....（公共头部）
帮助中心、交流合作、站内地图...(公共底部)
java、c++、python...（公共分类）
python学科视频
--------------------------------
Process exited after 0.2872 seconds with return value 0
请按任意键继续. . .c++重载运算符和重载函数：C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。
#include<iostream>
using namespace std;
class student
{
public:
void name(string a)
{
cout<<"姓名为："<<a<<endl;
}
void sex(string c)
{
cout<<"性别为："<<c<<endl;
}
void stu_id(int b)
{
cout<<"学号："<<b<<endl;
}
} ;
int main()
{
student stu;
stu.name("小红");
stu.stu_id(36);
stu.sex("女");
return 0;
}运行结果：
姓名为：小红
学号：36
性别为：女
--------------------------------运算重载 ：
重定义或重载大部分 C++ 内置的运算符，重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表
Person operator+ (Person &p) ；
Person operator+ (Person &p1，Person &p2)；#include <iostream>
using namespace std;
class Box
{
public:
double getVolume(void)
{
return length * breadth * height;
}
void setLength( double len )
{
length = len;
}
void setBreadth( double bre )
{
breadth = bre;
}
void setHeight( double hei )
{
height = hei;
}
// 重载 + 运算符，用于把两个 Box 对象相加
Box operator+(const Box& b)
{
Box box;
box.length = this->length + b.length;
box.breadth = this->breadth + b.breadth;
box.height = this->height + b.height;
return box;
}
private:
double length; // 长度
double breadth; // 宽度
double height; // 高度
};
// 程序的主函数
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
Box Box3; // 声明 Box3，类型为 Box
double volume = 0.0; // 把体积存储在该变量中
// Box1 详述
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// Box2 详述
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// Box1 的体积
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume <<endl;
// Box2 的体积
volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume <<endl;
// 把两个对象相加，得到 Box3
Box3 = Box1 + Box2;
// Box3 的体积
volume = Box3.getVolume();
cout << "Volume of Box3 : " << volume <<endl;
return 0;
}
运行结果：
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400C++ 多态：
多种状态，当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。
C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
多态分为两类：
- 静态多态：函数重载和运算重载属于静态多态，复用函数名。
- 动态多态：派生类和虚函数实现运行时多态。
两者区别：
静态多态的函数地址早绑定-编译阶段确定函数地址；
动态多态的函数地址晚绑定-运行阶段确定函数地址；
多态满足条件：
- 有继承关系
- 子类重写父类中的函数；
实例：
#include <iostream>
using namespace std;
class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width = a;
height = b;
}
int area()
{
cout << "Parent class area :" <<endl;
return 0;
}
};
class Rectangle: public Shape{
public:
Rectangle( int a=0, int b=0):Shape(a, b) { }
int area ()
{
cout << "Rectangle class area :" <<endl;
return (width * height);
}
};
class Triangle: public Shape{
public:
Triangle( int a=0, int b=0):Shape(a, b) { }
int area ()
{
cout << "Triangle class area :" <<endl;
return (width * height / 2);
}
};
// 程序的主函数
int main( )
{
Shape *shape;
Rectangle rec(10,7);
Triangle tri(10,5);
// 存储矩形的地址
shape = &rec;
// 调用矩形的求面积函数 area
shape->area();
// 存储三角形的地址
shape = &tri;
// 调用三角形的求面积函数 area
shape->area();
return 0;
}
运行结果：
Parent class area
Parent class area对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual
class Shape {
protected:
int width, height;
public:
Shape( int a=0, int b=0)
{
width = a;
height = b;
}
virtual int area()
{
cout << "Parent class area :" <<endl;
return 0;
}
};
修改后运行结果：
Rectangle class area
Triangle class area虚函数：
是在基类中使用关键字 virtual 声明的函数。
扫一扫
624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
