Review cpp day05

最新推荐文章于 2024-09-29 23:53:24 发布
最新推荐文章于 2024-09-29 23:53:24 发布
阅读量107 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42284219/article/details/116456257
版权

回顾：
Review cpp day01
Review cpp day02
Review cpp day03
Review cpp day04

十五、this指针和常成员函数（常函数）

1、this指针

  • 类中的函数都隐藏一个该类类型的指针参数，名为this
    • 对于普通的成员函数，this指针指向调用函数的对象
    • 对于构造函数，this指向正在创建的对象

eg:

class A{
public:
	A(int i):m_i(i){}
	void print(void){
		cout << m_i << endl;
	}/*print编译后就会编程类似下面：*/
	void print(A* this){
		cout << this->m_i << endl;
	}
	int m_i;
};
int main(void){
	A a1(100);
	a a2(200);
	//A::print(&a1)
	a1.print();//100
	//A::print(&a2)
	a2.print();//200	
	return 0;
}

06this.cpp

#include <iostream>
using namespace std;

class User{
public:
	User(const string& name, int age)
		:m_name(name), m_age(age){
		cout << "构造函数this地址：" << this << endl;
	}
	void who(void){
		cout << m_name << ',' << m_age << endl;
	}
	/*
	void who(User* this){
		cout << this->m_name << ',' << this->m_age << endl;
	}
	*/
private:
	string m_name;
	int m_age;
};
int main(void){
	User u1("张飞",28);
	cout << "&u1=" << &u1 << endl;
	User u2("赵云",25);
	cout << "&u2=" << &u2 << endl;
	u1.who();//User::who(&u1);
	u2.who();//User::who(&u2);
	return 0;
}

2、需要显式使用this指针的场景

  • 区分作用域

07this.cpp

#include <iostream>
using namespace std;

class User{
public:
	//通过this指针区分成员变量和参数变量
	User(const string& m_name, int m_age){
		this->m_name = m_name;
		this->m_age = m_age;
	}
	void who(void){
		cout << m_name << ',' << m_age << endl;
	}
private:
	string m_name;
	int m_age;
};
int main(void){
	User u1("张飞",28);
	cout << "&u1=" << &u1 << endl;
	User u2("赵云",25);
	cout << "&u2=" << &u2 << endl;
	u1.who();//User::who(&u1);
	u2.who();//User::who(&u2);
	return 0;
}
  • 从成员函数返回调用对象自身

08this.cpp

#include <iostream>
using namespace std;

class Counter{
public:
	Counter(int num=0):m_num(num){}
	//Counter& add(Counter* this){
	Counter& add(void){
		//++this->m_num;
		++m_num;
		//this指向调用对象
		//*this就是调用对象自身
		return *this;//返回自引用
	}
	int m_num;
};
int main(void){
	Counter cn(1);
	//Counter::add(&cn);
	cn.add().add().add();
	cout << cn.m_num << endl;//4
	return 0;
}
  • 从类的内部销毁对象自身

09this.cpp

#include <iostream>
using namespace std;

class Counter{
public:
	Counter(int num=0):m_num(num){}
	//Counter& add(Counter* this){
	Counter& add(void){
		//++this->m_num;
		++m_num;
		//this指向调用对象
		//*this就是调用对象自身
		return *this;//返回自引用
	}
	void destory(void){
		cout << "this=" << this << endl;
	}
	int m_num;
};
int main(void){
	Counter* pc = new Counter(123);
	cout << pc->m_num << endl;//123
	cout << "pc=" << pc << endl;
	//delete pc;
	//pc = NULL;
	pc->destory;
	return 0;
}

2、常函数

  • 1）在一个成员函数参数表后面加上const修饰，这个成员函数就是常成员函数（常函数）。
    返回值 函数名(形参表) const {//函数体}
  • 2）常函数中的this指针是一个常指针，不能在常函数中修改成员变量的值。
    注： 被mutable关键字修饰的成员变量可以在常函数中被修改。

09constFunc.cpp

#include <iostream>
using namespace std;

class A{
public:
	A(int data):m_data(data){}
	/*正常情况下不能再常函数中修改m_data，但是如
	*果m_data被mutable修饰就可以修改
	*/
	void print(void)const{//常函数
		cout << m_data << endl;
		//cout << m_data++ << endl;//防止出现修改成员函数的操作
	}
	/*void print(const A* this){//常函数
	*	//cout << m_data++ << endl;
	*}
	*/
	mutable int m_data;
};
int main(void){
	A a(100);
	a.print();//100
	return 0;
}
  • 3）非-常对象既可以调用非-常函数，也可以调用常函数；但是常对象只能调用常函数，不能调用非-常函数

10constFunc.cpp

#include <iostream>
using namespace std;
class A{
public:
	//void func1(const A* this)
	void func1(void)const{
		cout << "常函数" << endl;
		//在一个常函数里调用一个普通成员函数是错误的
		//func2();
	}
	//void func2(A* this)
	void func2(void){
		cout << "非-常函数" << endl;
		//在普通成员函数中调用常函数是可以的
		func1();
	}
};
int main(void){
	A a;//非-常对象
	a.func1();//A::func1(&a), A*
	a.func2();//ok
	const A a2 = a;//常对象
	a2.func1();//A::func1(&a2), const A*
	a2.func2();//error

	const A& ra = a;//常引用
	ra.func1()
	//ra.func2();//error
	
	const A* pa = &a;//常指针
	pa->func1();
	//pa->func2();//error

	return 0;
}
  • 4）函数名和形参表相同的成员函数，其常版本和非-常版本可以构成有效的重载，常对象调用常版本，非-常对象调用非-常版本。

11constFunc.cpp

#include <iostream>
using namespace std;

class A{
public:
	//void func(const A* this)
	void func(void)const{
		cout << "常版本" << endl;
	//void func(A* this)
	void func(void){
		cout << "非-常版本" << endl;
};
int main(void){
	A a1;
	a1.func();//非-常版本
	const A a2 = a1;
	a2.func();//常版本
	return 0;
}

十六、析构函数（Destructor）

1、语法

class 类名{
	~类名(void){
		//负责清理对象创建时的动态资源
	}
};
  • 1）函数名必须是“~类名”
  • 2）没有返回类型，也没有参数，所以也无法重载

2、当对象销毁时，该类的析构函数会自动被执行

  • 1）栈对象当离开作用域时，其析构函数被作用域终止的右花括号"}"调用
  • 2）堆对象的析构函数被delete操作符调用

12destructor.cpp

#include <iostream>
using namespace std;

class Integer{
public:
	Integer(int data = 0):m_data(new int(data)){
		//m_data = new int(data);
	}
	void print(void)const{
		cout << *m_data << endl;
	}
	~Integer(void){
		cout << "析构函数" << endl;
		delete m_data;
	}
private:
	int* m_data;
};
int main(void){
	if(1){
		Integer i(100);
		i.print();//100
		cout << "test1" << endl;

		Integer* pi = new Integer(200);
		pi->print();//200
		delete pi;//-->调用析构函数
		cout << "test3" << endl;
	}//-->调用析构函数
	cout << "test2" << endl;
	return 0;
}

100
test1
200
析构函数
test3
析构函数
test2

3、如果一个类没有定义析构函数，那么系统会为该类提供一个缺省的析构函数

  • 对于基本类型的成员，什么也不做；
  • 对于类类型的成员 变量（成员子对象），调用相应类的析构函数。

13destructor.cpp

#include <iostream>
using namespace std;

class A{
public:
	A(void){
		cout << "A::A()" << endl;
	}
	~A(void){
		cout << "A::~A()" << endl;
	}
};
class B{
public:
	B(void){
		cout << "B::B()" << endl;
	}
	~B(void){
		cout << "B::~B()" << endl;
	}
	A m_a;//类类型的成员变量
};
int main(void){
	B b;
	return 0;
}

A::A()
B::B()
B::~B()
A::~A()

4、对象创建和销毁的过程

  • 1）创建

    • 分配内存
    • 构造成员子对象（按声明顺序）
    • 执行构造函数代码

  • 2）销毁

    • 执行析构函数代码
    • 析构成员子对象（按声明逆序）
    • 释放内存

  • 扩展练习V3.0：实现企业员工管理系统

    • 需求：修改和完善员工类
      • 1）将打印员工信息改成常函数
      • 2）构造函数初始化操作改成初始化表
      • 3）在构造函数中打开一个文件，以工号命名，保存员工信息
    • 提示：
class Employee{
public:
	Employee(...):...{
		工号(int)-->工号(char*)//sprintf
		file = fopen(工号,"w");
		saveInfo();//保存员工信息
	}
	~Employee(void){
		fclose(file);
	}
private:
	FILE* file;
};

Employee.h

#include <iostream>
using namespace std;

class Employee{
public:
	Employee(int id, const string& name, double salary);
	Employee(void);
	~Employee(void);
	void printInfo(void)const;
	void calSalary(void);
	void setId(int id);
	void setName(const string& name);
	void setSalary(double salary);
	void saveInfo(void)  const;
private:
	int m_id;//工号
	string m_name;//姓名
	double m_salary;//工资
	FILE* file;//保存信息文件
};

Employee.cpp

#include "Employee.h"

Employee::Employee(int id, const string& name, double salary)
		:m_id(id), m_name(name), m_salary(salary){
	if(m_id>0){
		char filename[20] = {0};
		sprintf(filename, "%d", m_id);
		file = fopen(filename, "w");
		if(file == NULL){
			cout << "file open error" << endl;
		}
	}
	saveInfo();
}
Employee::~Employee(void){
	fclose(file);	
}
void Employee::printInfo(void)const{
	cout << "姓名：" << m_name << endl;
	cout << "工号：" << m_id << endl;
	cout << "基础工资：" << m_salary << endl; 
}
void Employee::calSalary(void){
	cout << "请输入出勤天数：";
	int days;
	cin >> days;
	double basic = m_salary * (days/23.0);
	double merit = basic / 2;
	cout << "总工资为：" << (basic + merit) << endl;
}
void Employee::setid(int id){
	if(id < 10000){
		cout << "无效的工号" << endl;
	}
	else{
		m_id = id;
	}
}
void Employee::setName(const string& name){
	if(name.size() > 20){
		cout << "无效的姓名" << endl;
	}
	else{
		m_name = name;
	}
}
void Employee::setSalary(double){
	if(salary < 0){
		cout << "无效工资" << endl;
	}
	else{
		m_salary = salary;
	}
}
void Employee::saveInfo(void)const{
	fseek(file, 0, SEEK_SET);
	fprintf(file, "%d %s %g", m_id, m_name.c_str(), m_salary);
}

main.cpp

#include "Employee.h"
int main(void){
	Employee emp(10001, "张三", 6600);
	emp.printInfo();
	emp.calSalary();
	
	Employee* pemp = new Employee(10002, "李四", 8800);
	pemp->printInfo();
	pemp->calSalary();
	return 0;
}
Ascenda
关注
Review cpp day07
weixin_42284219的博客
05-08 162
回顾： Review cpp day01 Review cpp day02 Review cpp day03 Review cpp day04 Review cpp day05 Review cpp day06 十九、成员指针//了解 1、成员变量指针 1）定义:类型 类名::*指针变量名 = &类名::变量; 2）使用 对象.*成员指针变量名; 注： ".*"称为成员指针解引用操作符 对象指针->*成员指针变量名; 注： "->*"称为间接成员指针解引用操作符 01menpt
Review cpp day09
weixin_42284219的博客
05-10 142
回顾： Review cpp day01 Review cpp day02 Review cpp day03 Review cpp day04 Review cpp day05 Review cpp day06 Review cpp day07 Review cpp day08 二十二、多态（Polymorphic） 1、虚函数覆盖（函数重写）、多态概念 如果将基类中的某个成员函数声明为虚函数，那么其子类中与该函数具有相同原型的成员函数也就是 虚函数，并且对基类中的版本形成覆盖。这时，通过指向子类对象的基类
Review cpp day10
weixin_42284219的博客
05-10 257
二十三、运行时的类型信息//了解 1、typeid操作符 #include typeid(类型/对象); 返回typeinfo的对象，用于描述类型信息，里面包含一个name的成员函数，可以将类型信息转化 为字符串形式。 typeinfo提供了对“==”和“!=”操作符重载的支持，通过它们可以直接进行类型之间的比较。 06typeid.cpp #include #include #include using namespace std; class X{ virtual void foo(){} };
Review cpp day06
weixin_42284219的博客
05-07 107
回顾： Review cpp day01 Review cpp day02 Review cpp day03 Review cpp day04 Review cpp day05 十七、拷贝构造和拷贝赋值 1、浅拷贝和深拷贝 1）如果一个类中包含指针形式的成员变量，缺省的拷贝构造函数只是复制指针变量本身，而没有复制指针所指向的内容，这中拷贝方式称为浅拷贝。 2）浅拷贝将会导致不同对象间的数据共享，同时会在析构函数中引发double free异常，因此就必须自己定义一个支持复制指针所指向内容拷贝构造函数，即深
Review cpp day08
weixin_42284219的博客
05-08 174
回顾： Review cpp day01 Review cpp day02 Review cpp day03 Review cpp day04 Review cpp day05 Review cpp day06 Review cpp day07 二十一、继承（Inheritance） 1、继承的概念 通过一种机制表达类型之间共性和特性的方式，利用已有的数据类型定义新的数据类型，这种机制就是继承。 eg: 人类：姓名、年龄、吃饭、睡觉 学生类：姓名、年龄、吃饭、睡觉、学号、学习 教师类：姓名、年龄、吃饭、
Review cpp day03
weixin_42284219的博客
05-04 111
回顾： Review cpp day01 Review cpp day02 十一、类型转换 1、隐式转换 char c = 'a'; int i = c;//隐式转换 void func(int i) {...} func(c);//隐式转换 int foo(void){ char c = 'a'; return c;//隐式转换 } 2、显式转换 2.1、C++兼容C的强制类型转换 char c = 'a'; int i = (int)c;//显式转换C风格 int i = int(c);//C
Review cpp day01
weixin_42284219的博客
05-02 119
一、第一个C++程序 01first.cpp #include <iostream> int main(void){ std::cout <<"hello world!"<<std::endl; return 0; } 1、两种编译程序方法： gcc 01first.cpp -lstdc++ ./a.out g++ 01first.cpp//推荐 2、文件扩展名 1）.cpp 2）.cxx 3）.cc 4）.c 3、头文件 包含了标准C++中所有和
Review cpp day02
weixin_42284219的博客
05-02 128
八、C++的函数 1、函数重载 1）定义：在相同作用域，定义同名的函数，但是它们的参数要有所区分，这样的多个函数构成重载关系。 注： 函数的重载和返回值无关 eg：图形库（包含很多绘图函数） //C语言实现 void drawCircle(int x, int y, double r){......} void drawRect(int x, int y, double w, double h){.....} ....... //C++语言实现 void draw(int x, int y, d
Review cpp day04
weixin_42284219的博客
05-06 111
回顾： Review cpp day01 Review cpp day02 Review cpp day03 十四、构造函数和初始化表 1、构造函数和普通的函数类似，也可以重载或带有缺省参数 05constuctor.cpp #include <iostream> using namespace std; class Student{ public: Student(const string& name, int age = 0, int id = 0){ cout <&l
8-07-14_MegaCLI for linux_windows
03-15
SCGCQ00319423 Defect FreeBSD MegaCLI v8.05.02 does not detect controller when driver 5.504.05.00 is loaded SCGCQ00324031 Defect MegaCLI 8.04.07 output typos SCGCQ00324525 Defect MegaCLI: MFI_STAT_NOT_...
我的.emacs(Ubuntu版)(二十二)
Android系统攻城狮
02-16 1037
;;Load site-lisp (add-to-list 'load-path "~/.emacs.d/site-lisp") ;;显示行号 (add-to-list 'load-path "/usr/share/emacs/site-lisp") (require 'linum) (global-linum-mode t) (setq column-number-mode t);显示列号 ...
PMP中英文术语对照
热门推荐
不怂，不弱，不退缩，厚积薄发
07-19 1万+
ABC|参见Activity Based Costing ABM|参见Activity Based Management Abstract Resource|抽象资源 Abstraction|抽象 AC|实际费用 Acceleration|加速 Acceptability Criteria|验收标准 Acceptable|可接受的 Acceptable Quality Level|(AQL) 可接受质量水平 Acceptance|验收 Acceptance Criteria|验收标准 Acceptance
板凳——————————————————c++(104)
fengye207161的博客
03-13 1559
c++ Primer Plus (第六版) #if 0 #include int main(){ unsigned int yards {}, feet{}, inches {}; std::cout << "Enter a distance as yards, feet, and inches " << “with the three values separated by spaces:” << std::endl; std::cin >> yards
pyqt瀑布流布局
weixin_54217201的博客
09-21 500
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 440
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
简易STL实现 | Set 的实现
AsherGu的博客
09-26 431
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
C++中的IO流
2301_80468112的博客
09-24 674
在C语言中，如果想要将一个整形变量的数据转化为字符串格式，如何去做？1. 使用itoa()函数2. 使用sprintf()函数但是两个函数在转化时，都得需要先给出保存结果的空间，那空间要给多大呢，就不太好界定，而且转化格式不匹配时，可能还会得到错误的结果甚至程序崩溃。在C++中，可以使用stringstream类对象来避开此问题。在程序中如果想要使用stringstream，必须要包含头文件。
06.C/C++内存管理
最新发布
2402_82670467的博客
09-29 695
在这里C++的内存管理相较于C作出了许多升级，下面我们就来了解一下。我们先来看一下下面的问题，温习一下C的内存分布 在 C/C++中，内存主要分为以下几个部分： 一、栈（Stack） 1. 存储内容： - 局部变量：函数内部声明的非静态变量。 - 函数参数：传递给函数的参数。 - 函数调用信息：如返回地址等。 2. 特点： - 先进后出（LIFO）的数据结构。 - 内存由编译器自动管理，当函数被调用时分配空间，函数返回时自动释放。 - 空间相对较小，通常几兆字节。 二、堆（Heap）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值