C++基础回顾（二）

最新推荐文章于 2022-08-01 17:18:58 发布

原创最新推荐文章于 2022-08-01 17:18:58 发布 · 453 阅读

0 ·

CC 4.0 BY-SA版权

编程语言专栏收录该内容

7 篇文章

订阅专栏

看视频课程：C++面向对象编程

第8节面向对象基础

第9节定义类和对象

struct 与 class 在C++中都可以定义类，struct默认为public，而class默认为private。

成员函数申明与定义的两种方式：

1.类内定义，类内实现，print()函数

2.类内定义，类外实现，getAge()函数

这里，第一种类内定义的默认为内联函数，类外定义的要手动添加inline！

第10节类和对象的使用

/*Student stu;
stu.print();
cout<<stu.getAge()<<endl;*/

/*Student stu;
Student *p = &stu;
p->print();
cout<<p->getAge()<<endl;*/

Student stu;
Student &s = stu;
s.print();
cout<<s.getAge()<<endl;

//使用宏指令，防止重复定义
#ifndef TIME_H
#define TIME_H
//...
#endif

头文件Time.h

#ifndef TIME_H
#define TIME_H
class CTime
{
public:
	void setHour(int hour);
	void setMinute(int minute);
	void setSecond(int second);

	int getHour();
	int getMinute();
	int getSecond();
private:
	int m_nHour;
	int m_nMinute;
	int m_nSecond;
};
#endif

cpp文件Time.cpp

#include "Time.h"

void CTime::setHour(int hour)
{
	m_nHour = hour;
}
void CTime::setMinute(int minute)
{
	m_nMinute = minute;
}
void CTime::setSecond(int second)
{
	m_nSecond = second;
}

int CTime::getHour()
{
	return m_nHour;
}
int CTime::getMinute()
{
	return m_nMinute;
}
int CTime::getSecond()
{
	return m_nSecond;
}

运行文件main.cpp

#include<iostream>
#include"Time.h"
using namespace std;

int main()
{
	CTime time;
	time.setHour(10);
	time.setMinute(50);
	time.setSecond(20);

	cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;
	return 0;
}

Visual Studio 2012常用快捷键总结

1）注释：组合键“Ctrl+K+C”；

2）取消注释：组合键“Ctrl+K+U”。

第11节构造函数和析构函数

CTime::CTime()    //默认构造函数
{
	m_nHour = 0;
	m_nMinute = 0;
	m_nSecond = 0;
}

CTime::~CTime()   //析构函数
{
	std::cout<<"~CTime"<<std::endl;
	std::cout << "Object is being deleted" << std::endl;
}

CTime::CTime(int value)      //带一个参数的构造函数
{
	m_nHour = value;
	m_nMinute = value;
	m_nSecond = value;
}

CTime::CTime(int hour, int minute, int second)
{
	m_nHour = hour;
	m_nMinute = minute;
	m_nSecond = second;
}

没有构造函数时会提供默认不带参的构造函数，有构造函数时就不会提供默认构造函数了！

注意一下，默认参数构造函数，不能给所有参数提供默认值，这样可能会导致歧义！

第12节this指针和复制构造函数

复制构造函数也是构造函数的一种，有了复制构造函数就不会有默认的构造函数了

this指针：

void CTime::setMinute(int minute)
{
    m_nMinute = minute;    //this指针隐藏
    //this->m_nMinute = minute;       //->方式
    //(*this).m_nMinute = minute;     //.方式，this是指针，*this是对象
}

复制构造函数：

CTime::CTime(CTime& time)
{
	m_nHour = time.m_nHour;
	m_nMinute = time.m_nMinute;
	m_nSecond = time.m_nSecond;
	cout<<"Copy constructor!"<<endl;
}

//1.以其对象作为参数创建新对象时
CTime time5(time);

//2.类对象（传值）作为函数参数时
void func1(CTime time)
{
 cout<<time.getHour();
}

//3.类对象作为参数返回值时
/*CTime func1(CTime time)
{
 cout<<time.getHour();
 return time;
}*/
//应该为引用的方式返回，较少复制产生花销，注意不能返回局部变量的引用：
CTime& func1(CTime& time)
{
 cout<<time.getHour();
 return time;
}

第14节const对象和const成员

const数据成员，不能在构造函数里赋值，只能通过初始化列表初始化，且每个构造函数要用初始化列表对其进行初始化。

初始化列表形式如下：a(1),b(2)

CTime::CTime()
	:m_nNum(10)
{
	m_nHour = 0;
	m_nMinute = 0;
	m_nSecond = 0;
	//这样编译不通过
	//m_nNum = 0;
}
CTime::CTime(int value)
	:m_nNum(20)
{
	m_nHour = value;
	m_nMinute = value;
	m_nSecond = value;
}
CTime::CTime(int hour, int minute, int second)
	:m_nNum(1)
{
	m_nHour = hour;
	m_nMinute = minute;
	m_nSecond = second;
}
CTime::CTime(CTime& time)
	:m_nNum(time.m_nNum)
{
	m_nHour = time.m_nHour;
	m_nMinute = time.m_nMinute;
	m_nSecond = time.m_nSecond;
	cout<<"Copy constructor!"<<endl;
}

//const数据成员
const int m_nNum;

//const成员函数
int getNum()const;

int CTime::getNum()const{return m_nNum;}

//const对象time和time2
const CTime time(10, 50, 20);
CTime const time2(12, 20, 12);
/*const对象不能调用非const类型的成员函数
time.getHour();
time2.setHour();*/
cout<<time.getNum()<<endl;

第15节友元

1.将非成员函数声明为友元：

在CTime类的头文件Time.h中添加，友元函数，要访问CTime类的私有数据成员

//将非成员函数声明为友元函数
friend void func();

void func()
{
	CTime time(1,1,1);
	cout<<time.m_nHour<<endl;
	time.m_nHour = 3;
	cout<<time.m_nHour<<endl;
}

2.友元类、其他类的成员函数声明为友元函数
注意一下友元类的声明位置与其他类声明为友元函数时的声明位置，实例如下：

CDate类要访问CTime类的私有成员，即在CTime类的头文件Time.h中添加，友元类或友元函数

//友元类
//friend CDate;
//友元函数即可
friend void CDate::display(const CTime& time);

Date.h文件

#ifndef DATE_H
#define DATE_H

//类前置声明
class CTime;
class CDate
{
public:
	//构造函数
	CDate(int year, int month, int day);

	//友元类，不能索取，只能给与，所以应该在CTime类中声明友元类CDate
	//friend CTime;
	void display(const CTime& time);
private:
	int m_nYear;
	int m_nMonth;
	int m_nDay;
};
#endif

Date.cpp

#include"Date.h"
#include"Time.h"
#include<iostream>

CDate::CDate(int year, int month, int day)
	:m_nYear(year), m_nMonth(month), m_nDay(day)
{
}
void CDate::display(const CTime& time)
{
	 std::cout<<m_nYear<<"-"<<m_nMonth<<"-"<<m_nDay<<" "<<time.m_nHour<<":"<<time.m_nMinute<<":"<<time.m_nSecond<<std::endl;
}

main.cpp

const CTime time(10, 50, 20);
CDate date(2018,1,22);
date.display(time);

第16节运算符重载基础

1.一般的函数（加法运算，两个参数）

CTime operator+(CTime& time1, CTime& time2)
{
	int nHour = 0, nMinute = 0;
	int nSecond = time1.m_nSecond + time2.m_nSecond;
	if(nSecond > 60)
	{
		nMinute ++;
		nSecond -= 60;
	}
	nMinute += (time1.m_nMinute + time2.m_nMinute);
	if(nMinute > 60)
	{
		nHour ++;
		nMinute -= 60;
	}
	nHour += (time1.m_nHour + time2.m_nHour);
	if(nHour > 24)
	{
		nHour -= 24;
	}
	//构造临时CTime对象
	return CTime(nHour, nMinute, nSecond);
}

2.类的成员函数（加法运算，一个参数）

CTime CTime::operator+(CTime& time)
{
	int nHour = 0, nMinute = 0;
	int nSecond = this->m_nSecond + time.m_nSecond;
	if(nSecond > 60)
	{
		nMinute ++;
		nSecond -= 60;
	}
	nMinute += (this->m_nMinute + time.m_nMinute);
	if(nMinute > 60)
	{
		nHour ++;
		nMinute -= 60;
	}
	nHour += (this->m_nHour + time.m_nHour);
	if(nHour > 24)
	{
		nHour -= 24;
	}
	//构造临时CTime对象
	return CTime(nHour, nMinute, nSecond);
}

第17节运算符重载规则

CTime& CTime::operator=(CTime& time)
{
	//判断是否为同一个对象,是一个则返回该对象(*this)
	if(this == &time)
	{
		return *this;
	}
	m_nHour = time.m_nHour;
	m_nMinute = time.m_nMinute;
	m_nSecond = time.m_nSecond;

	return *this;
}

//调用类的赋值运算函数
time = time3;
cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;

//调用复制构造函数
CTime time4 = time3;
CTime time5(time3);

需要将以上两者进行区分，容易混淆！！

第18节重载二元和一元运算符

==与>运算符重载

bool CTime::operator==(CTime& time)
{
	if(m_nHour == time.m_nHour && m_nMinute == time.m_nMinute && m_nSecond == time.m_nSecond)
	{
		return true;
	}
	return false;
}

bool CTime::operator>(CTime& time)
{
	if(m_nHour > time.m_nHour)
	{
		return true;
	}
	else if(m_nHour < time.m_nHour)
	{
		return false;
	}
	else
	{
		if(m_nMinute > time.m_nMinute)
		{
			return true;
		}
		else if(m_nMinute < time.m_nMinute)
		{
			return false;
		}
		else
		{
			if(m_nSecond > time.m_nSecond)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
	return false;
}

bool bRet = time == time2;
bool bRet2 = time > time2;

前置++与后置++运算符重载，前置无参数，后置参数（int）

CTime CTime::operator++()
{
	//可以写个函数实现++，更方便的是使用加法的重载函数
	//定义time对象(0,0,1)加到当前对象(*this)
	CTime time(0, 0, 1);
	*this = *this + time;
	return *this;
}

CTime CTime::operator++(int)
{
	//要返回++前的对象，赋值给time
	CTime time = *this;
	//可以写个函数实现++，更方便的是使用加法的重载函数
	//定义time对象(0,0,1)加到当前对象(*this)
	CTime time2(0, 0, 1);
	*this = *this + time2;
	return time;
}

++time2;
cout<<time2.getHour()<<":"<<time2.getMinute()<<":"<<time2.getSecond()<<endl;
time = time2++;
cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;
cout<<time2.getHour()<<":"<<time2.getMinute()<<":"<<time2.getSecond()<<endl;

第19节流插入、提取运算符和类型转换

//流提取>>运算符重载，作为友元函数，不能作为成员函数
istream& operator>>(istream& input, CTime& time)
{
	cin>>time.m_nHour>>time.m_nMinute>>time.m_nSecond;
	return input;
}
//流插入<<运算符重载，作为友元函数，不能作为成员函数
ostream& operator<<(ostream& output, CTime& time)
{
	cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;
	return output;
}

CTime time2(12);
cin>>time1;
cout<<time1<<endl<<time2<<endl;

1.使用构造函数进行类型转换

CTime time2(12);
time2 + CTime(3);
CTime time3(20);
CTime time4 = 20;
CTime time5 = CTime(20);

有了转换构造函数，以上都不会编译报错，然而：

//具有一个参数的构造函数可以用来做类型转换————称为转换构造函数
//有人说这样方便，也有不同意的人
//通过加关键字explicit,可以防止类型转换
explicit CTime(int value);

2.类型转换函数进行类型转换（不常见）

//类型转换函数,CTime对象转换为int类型
CTime::operator int()
{
	return m_nHour * 60 * 60 + m_nMinute * 60 + m_nSecond; 
}

CTime time(10,50,20)
int nSecond = time;