电商需要了解的知识,淘宝关键词优化技巧,wordpress 下载网站模板,wordpress调用爱奇艺本专栏记录C学习过程包括C基础以及数据结构和算法#xff0c;其中第一部分计划时间一个月#xff0c;主要跟着黑马视频教程#xff0c;学习路线如下#xff0c;不定时更新#xff0c;欢迎关注。 当前章节处于#xff1a; ---------第1阶段-C基础入门 ---------第2阶段实战… 本专栏记录C学习过程包括C基础以及数据结构和算法其中第一部分计划时间一个月主要跟着黑马视频教程学习路线如下不定时更新欢迎关注。 当前章节处于 ---------第1阶段-C基础入门 ---------第2阶段实战-通讯录管理系统 第3阶段-C核心编程 ---------第4阶段实战-基于多态的企业职工系统 ---------第5阶段-C提高编程 ---------第6阶段实战-基于STL泛化编程的演讲比赛 ---------第7阶段-C实战项目机房预约管理系统 文章目录 一、 封装1.1 封装基本概念1.2 访问权限1.3 成员属性设置成私有 二、对象特性2.1 对象的初始化和清理2.2 构造函数的分类与调用2.3 构造函数调用规则2.4 浅拷贝与深拷贝2.5 初始化列表2.6 类对象作为类成员2.7 静态成员 三. C对象模型和this指针3.1 成员变量和成员函数分开存储3.2 this指针概念3.3 空指针访问成员函数3.4 const修饰成员函数 类和对象是C的核心C面向对象的三大特性封装、继承、多态,C认为万事万物都是对象对象尤其属性和行为。
一、 封装
1.1 封装基本概念
封装是C面向对象三大特性之一意义在于
将属性和行为作为一个整体表现生活中的事务将属性和行为加以权限控制
语法 class 类名{ 访问权限属性/ 行为}; 代码举例说明设计一个圆类计算圆的周长
#include iostream
using namespace std;
#define PI 3.14
class Circle {// 权限
public://属性int r 0;// 行为double getLength() {return r * r * PI;}
};int main() {// 实例化对象Circle c1;c1.r 3;cout 圆的周长为 c1.getLength() endl;system(pause);return 0;}圆的周长为28.26
请按任意键继续. . .创建类后需要实例化才可以使用相当于类是一个模具实例化出来的对象才是产品。
#include iostream
using namespace std;
class Student {// 权限
public:// 属性string name;string cardnum;// 行为string getname() {return name;}string getcardnum() {return cardnum;}
};int main() {// 实例化对象Student stu;stu.name 张三;stu.cardnum 123;cout 姓名为 stu.getname() 学号为 stu.getcardnum() endl;system(pause);return 0;}姓名为张三 学号为123
请按任意键继续. . .1.2 访问权限
访问权限分为三种
public 公共权限类内可以访问类外可以访问protected 保护权限 类内可以访问类外不可以访问private 私有权限类内可以访问类外不可以访问
protected和private区别在于继承时儿子可以继承父亲中的protected内容不可以继承父亲中private中内容
#include iostream
using namespace std;
class Person {
public:string name;
protected:string car;
private:string password;
public:void test() {// 类内都可以访问name 张三;car 自行车;password 12345;}
};int main() {Person p1;p1.name 李四;// 类外可以访问// p1.car; // 类外不可访问// p1.password;// 类外不可访问system(pause);return 0;}struct也可以定义类但是struct默认权限是公共权限而class默认权限是公有
#include iostream
using namespace std;
class test1 {// 默认私有int a 0;
};
struct test2 {// 默认公共int b 0;
};int main() {test1 test_1;test_1.a 10; // 不能访问test2 test_2;test_2.b 20; // 可以访问system(pause);return 0;}1.3 成员属性设置成私有
优点在于
将所有成员属性设置成私有可以自己控制读写权限对于写权限可以检测数据的有效性
通过get和set方法进行访问和赋值
#include iostream
using namespace std;class Student {// 权限
private:// 属性string name张三; // 可读可写string cardnum123;// 只读int score0; // 只写
public:// 可读可写void setname(string inputname) {name inputname;}string getname() {return name;}// 只读string getcarnum() {return cardnum;}// 只写void setscore(int inputscore) {score inputscore;}
};
int main() {Student stu;cout stu.getname() endl;stu.setname(李四);cout stu.getname() endl;system(pause);return 0;}张三
李四
请按任意键继续. . .可以用get和set方法进行值的合法性判断。 练习案例1设计立方体类
设计立方体类Cube求出立方体的表面积和体积分别用全局函数和成员函数判断两个立方体是否相等
全局函数需要传入两个实例化对象成员函数只要传入一个实例化对象即可
#include iostream
using namespace std;
class Cube {
public:double x0.0f; // 边长double y0.0f; // 边长double z0.0f; // 边长void setinf(double inputx, double inputy, double inputz) {x inputx;y inputy;z inputz;}int getS() {return 3 * (x * yx*zy*z);}int getV() {return x * y * z;}bool judge(Cube c2) {if ((c2.x x)(c2.yy)(c2.zz)){return true;}else {return false;}}
};
// 定义全局函数
bool g_judge(Cube c1, Cube c2) {if ((c2.x c1.x) (c2.y c1.y) (c2.z c1.z)) {return true;}else {return false;}
}
int main() {Cube c1,c2; // 创建c1.setinf(1, 2, 3);c2.setinf(2, 3, 4);cout c1表面积 c1.getS() endl;cout c1体积 c1.getV() endl;// 成员函数判断string flag c1.judge(c2) ? Yes : No;cout 通过成员函数判断两立方体是否相等: flag endl;// 全局函数判断string g_flag g_judge(c1,c2) ? Yes : No;cout 通过全局函数判断两立方体是否相等: flag endl;system(pause);return 0;}c1表面积33
c1体积6
通过成员函数判断两立方体是否相等:No
通过全局函数判断两立方体是否相等:No
请按任意键继续. . .练习案例2点和圆的关系 计算一个圆形类Circle)和一个点类Point计算点和圆的关系
#include iostream
using namespace std;
class Circle {
public:int x 0;int y 0;int r;void set_inf(int inputx,int inputy,int inputr) {x inputx;y inputy;r inputr;}
};class Point {
public:int P_x 0;int P_y 0;void set_inf(int input_P_x, int input_P_y) {P_x input_P_x;P_y input_P_y;}
};string judge(Circle c, Point p) {int distance sqrt((c.x - p.P_x)*(c.x - p.P_x) (c.y - p.P_y)*(c.y - p.P_y));if (distance c.r) {return 在圆上;}else if (distance c.r) {return 在圆内;}else {return 在圆外;}
}
int main() {Circle c1;Point p1;c1.set_inf(1, 1, 1);p1.set_inf(1, 0);string flag judge(c1, p1);cout flag endl;system(pause);return 0;}在圆上
请按任意键继续. . .代码比较多可以分文件编写分成Circle.cppCircle.hPoint.hPoint.cppcpp中放函数实现方法.h中放函数申明
circle.cpp
#include circle.h
void Circle::set_inf(int inputx, int inputy, int inputr) {x inputx;y inputy;r inputr;
};circle.h
#pragma once
#include iostream
using namespace std;class Circle {
public:int x 0;int y 0;int r;void set_inf(int inputx, int inputy, int inputr);
};point.cpp
#include point.hvoid Point::set_inf(int input_P_x, int input_P_y) {P_x input_P_x;P_y input_P_y;
}
point.h
#pragma once
#include iostream
using namespace std;class Point {
public:int P_x 0;int P_y 0;void set_inf(int input_P_x, int input_P_y);
};main.cpp
#include iostream
using namespace std;
#include circle.h
#include point.h
//class Circle {
//public:
// int x 0;
// int y 0;
// int r;
// void set_inf(int inputx,int inputy,int inputr) {
// x inputx;
// y inputy;
// r inputr;
// }
//};//class Point {
//public:
// int P_x 0;
// int P_y 0;
// void set_inf(int input_P_x, int input_P_y) {
// P_x input_P_x;
// P_y input_P_y;
// }
//};string judge(Circle c, Point p) {int distance sqrt((c.x - p.P_x)*(c.x - p.P_x) (c.y - p.P_y)*(c.y - p.P_y));if (distance c.r) {return 在圆上;}else if (distance c.r) {return 在圆内;}else {return 在圆外;}
}
int main() {Circle c1;Point p1;c1.set_inf(1, 1, 1);p1.set_inf(1, 0);string flag judge(c1, p1);cout flag endl;system(pause);return 0;}在圆上
请按任意键继续. . .二、对象特性
2.1 对象的初始化和清理
C面向对象来源于生活每个对象都会有初始化设置以及对象销毁前的清理数据设置。对象的初始化和清理也是两个非常重要的安全问题。
一个对象或者变脸没有初始状态对其使用后果是未知。同样使用完一个对象或变量没有及时清理也会造成一定的安全问题。
C利用构造函数 和析构函数解决以上问题两个函数会被编译器自动调用如果不提供构造和析构编译器会提供构造函数和析构函数的空实现。
构造函数创建对象时为对象的成员属性赋值析构函数对象销毁前系统自动调用执行一些清理工作。
构造函数语法 类名(){}
构造函数没有返回值也不写void函数名称与类名相同构造函数可以有参数因此可以发生重载程序在调用对象时候会自动调用构造无须手动调用而且只会调用一次
析构函数语法~类名(){}
析构函数没有返回值也不写void函数名称与类名相同在名称前加上符号~析构函数不可以有参数因此不可以发成重载程序在对象销毁前会自动调用析构无须手动调用而且只会调用一次
#include iostream
using namespace std;
class Person {
public: // 加上作用域Person() {cout 构造函数的调用 endl;}~Person() {cout 析构函数的调用 endl;}
};void test() {Person p; // 在栈区创建实例化对象
}
int main() {test();system(pause);return 0;
}构造函数的调用
析构函数的调用
请按任意键继续. . .2.2 构造函数的分类与调用
分类方式
按参数分有参构造和无参构造按类型分普通构造和拷贝构造
调用方式
括号法显示法隐式转化法
#include iostream
using namespace std;class Person {// 构造函数// 分类方式有参构造、无参构造 普通构造和拷贝构造// 无参构造
public:Person() {cout 调用的为无参构造 endl;}// 有参构造Person(int a) {age a;cout 调用的为有参构造 endl;}// 以上都为普通构造// 拷贝构造Person(const Person p) {age p.age;cout 调用的为拷贝构造 endl;}int age;
};int main() {// 调用方式// 1. 括号法// 无参调用Person p1;// 有参调用Person p2(10);// 拷贝调用Person p3(p2);// 2.显示法Person p4 Person(10);// Person(p4); 不可用拷贝构造 初始化匿名函数Person p5 Person(p4); // Person(p4)为匿名对象当前行执行结束后会立即被析构掉// 隐式转化法Person p6 10; //相当于Person p6 Person(10)system(pause);return 0;
}调用的为无参构造
调用的为有参构造
调用的为拷贝构造
调用的为有参构造
调用的为拷贝构造
调用的为有参构造
请按任意键继续. . .拷贝构造函数使用时机
使用一个已经创建完毕的对象来初始化一个新对象值传递的方式给函数参数传值值方式返回局部对象
#include iostream
using namespace std;
class Person {
public:Person() {cout 无参构造 endl;}Person(int a) {age a;cout 有参构造 endl;}Person(const Person p) {age p.age;cout 拷贝构造 endl;}int age;
};void test() {Person p1(10);Person p2(p1); // 用一个已经创建好的对象来初始化一个新对象cout p1的年龄为 p1.age endl;cout p2的年龄为 p2.age endl;}
void test2(Person p) {
}Person test3() {static Person p;return p;
}
//void todo() {
// test3();
//}
int main() {//Person p(10);Person p test3();system(pause);return 0;
}无参构造
拷贝构造
请按任意键继续. . .值传递的方式给函数参数传值和值方式返回局部对象都相当于将原来的值拷贝了一份,因此相当于把原来的拷贝了一份.
2.3 构造函数调用规则
如果用户定义有参构造函数C不再提供默认无参构造但是会提供默认拷贝构造如果用户定义拷贝构造函数C不会再提供其他构造函数
可以这么理解 拷贝构造有参构造无参构造如果用户提供一个构造编译器会自动补齐比他更高级的构造不会提供比他更低级的构造。比如如果用户定义有参构造函数C不再提供默认无参构造但是会提供默认拷贝构造
#include iostream
using namespace std;class Person {
public:Person(int a) {m_age a;}int m_age;
};int main() {//Person p;// 报错Person p(10); // 不报错Person p2(p); // 不报错system(pause);return 0;}2.4 浅拷贝与深拷贝
浅拷贝简单的赋值拷贝操作深拷贝在堆区重新申请空间进行拷贝操作
#include iostream
using namespace std;
class Person {
public:Person() {cout 无参构造 endl;}Person(int a,int n) {cout 有参构造 endl;age a;// num n;报错num new int(n);}Person(const Person p) {cout 拷贝函数 endl;age p.age;//num p.num; // 报错num new int (*p.num);}// 析构函数~Person() {cout 调用析构函数 endl;// 将指针开辟区域释放if (num ! NULL) {delete num;num NULL;}}int age;int* num; // 指针在堆区开辟
};
void test() {int num 123;// 有参构造Person p1(10, num);// 拷贝构造Person p2(p1); // 报错
}
int main() {test();system(pause);return 0;}有参构造
拷贝函数
调用析构函数
调用析构函数
请按任意键继续. . .主要原因就是浅拷贝的地址被释放之后二次释放。深拷贝会重新开辟一个地址这样就不会再同一个地址释放多次。
2.5 初始化列表
语法构造函数属性1值1属性2值2…{}
#include iostream
using namespace std;class Person {
public:Person() {}Person(string n,int a,string ad):name(n),age(a),address(ad){}string name;int age;string address;
};int main() {Person p1(张三, 13, 安徽);cout 姓名 p1.name 年龄 p1.age 住址 p1.addressendl;//Person p2(李四, 12); //报错少参数//cout 姓名 p2.name 年龄 p2.age 住址 p2.address endl;system(pause);return 0;}姓名张三 年龄13 住址安徽
请按任意键继续. . .2.6 类对象作为类成员
#include iostream
using namespace std;class Student {
public:string name;int score;Student(string n,int s):name(n),score(s){cout Student有参构造 endl;}~Student() {cout Student析构函数 endl;}};class Teacher {
public:string name;Student stu;Teacher(string t_n,string s_n,int s):name(t_n),stu(s_n,s){}
};void test() {Teacher t1(李老师, 张三, 12);cout 老师姓名 t1.name 学生姓名: t1.stu.name 学生分数 t1.stu.score endl;
}
int main() {test();system(pause);return 0;}Student有参构造
老师姓名李老师 学生姓名:张三 学生分数12
Student析构函数
请按任意键继续. . .2.7 静态成员
在成员变量和成员函数前加上关键字static,成为静态成员分为 静态成员变量 所有对象共享同一份数据在编译阶段分配内存类内声明类外初始化 静态成员函数 所有对象共享同一个函数静态成员函数只能访问静态成员变量
#include iostream
using namespace std;
class Person {
public:string name;static int score; // 静态成员变量需要类内定义类外初始化void func() {name 张三;score 10;cout 调用函数func endl;}static void func2() {//name 李四; // 报错静态成员函数只能调用静态成员变量score 200;cout 调用函数func2 endl;}
};
int Person::score100;int main() {Person p1;cout p1分数为 p1.score endl;Person p2;p2.score 60;cout p2分数为 p2.score endl;cout p1分数为 p1.score endl;// 直接使用类名调用静态成员变量cout Person::score: Person::score endl; // 注意不能使用. 而是使用::// 静态成员函数p2.func();p2.func2();system(pause);return 0;}p1分数为100
p2分数为60
p1分数为60
Person::score:60
调用函数func
调用函数func2
请按任意键继续. . .三. C对象模型和this指针
3.1 成员变量和成员函数分开存储
C中类内成员变量和成员函数分开存储只有非静态成员变量才属于类的对象上。
#include iostream
using namespace std;
class Person {
public:int a; // 是类的对象static int b;// 不是类的对象void func() {}static void func2(){}
};
int Person::b 0;
int main() {Person p;cout size of p sizeof(p) endl;system(pause);return 0;}size of p4
请按任意键继续. . .3.2 this指针概念
c提供特殊的对象指针——this指针this指针指向被调用的成员函数所属对象。this指针本质是一个指针常量指向对象不能发生变化指向对象的值可以发生变化。
this指针时隐含每一个非静态成员函数内的一种指针this指针不需要定义直接使用即可
this指针的用途
当形参和成员变量同名时可用this指针来区分在类的非静态成员函数中返回对象本身可使用return *this
#include iostream
using namespace std;
class Person {
public:int age;Person(int age) {//age age; // 编译器认为这两个age是一样的//1. 防止形参和成员变量同名this-age age; // 将形参age赋值给成员变量age}//2. 返回对象本身// 如果不是引用类型的话每一次都会创建一个新对象而不是在原来的对象上进行累加Person Personadd(Person p) {this-age p.age;return *this;}
};int main() {Person p(10);Person p1(20);cout p年龄 p.age endl;cout p1年龄 p.age endl;p1.Personadd(p).Personadd(p); // 加两次cout 年龄 p1.age endl;system(pause);return 0;}p年龄10
p1年龄10
年龄40
请按任意键继续. . .3.3 空指针访问成员函数
空指针可以调用成员函数但是要注意有没有用到this指针。如果用到了this指针需要加以判断保证代码的健壮性
#include iostream
using namespace std;class Person {
public:int age;void func() {cout func的调用 endl;}void func2() {// 添加判断 增强代码的健壮性if (this NULL) {return;}cout 年龄为 age endl; // age相当于this.age 如果是空指针的话会报错}
};int main() {// 创建一个空指针Person* p NULL;p-func();p-func2(); // 用到this指针会报错system(pause);return 0;}func的调用
请按任意键继续. . .3.4 const修饰成员函数
常函数
成员函数后加const后我们称这个函数为常函数常函数不可以修改成员属性成员属性声明时加关键字mutable后在常函数中仍然可以修改
常对象
声明对象前加const称该对象为常对象常对象只能调用常函数
#include iostream
#include iostream
using namespace std;
class Person{
public:string name; //成员变量mutable int age; // mutable修饰使得常函数也能进行修改// 无参构造函数Person() {}// 定义一个成员函数void test() {cout 调用test函数 endl;}// 定义一个常函数void func() const{//name 李四; // 报错不能修改正常的成员属性age 12; // 不报错可以修改mutable修饰的成员变量}};int main() {// 创建一个常对象const Person p;//p.test();// 不可以调用正常的成员函数p.func(); // 可以调用常函数cout 年龄为 p.age endl;system(pause);return 0;}年龄为12
请按任意键继续. . .
