9、C++高级语法

最新推荐文章于 2023-10-04 18:33:09 发布
最新推荐文章于 2023-10-04 18:33:09 发布
阅读量588 收藏
点赞数
分类专栏： C++知识体系重构 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq23001186/article/details/125406579
版权

目录

一、面向对象基础

1 - 面向对象定义

  • C++定义类：C++使用struct、class来定义一个类
  • struct和class区别
    • struct的默认成员权限是public
    • class的默认成员权限是private

2 - 面向对象构造与析构

  • 让自定义的类像内置类型一样
    • 一个int型的变量，可以完成+、-、*、/、比较、输出、++等一系列操作
    • 如果现在有一个自定义的复数类型，那么它的操作应该什么样？
      • 我们希望可以像使用int一样自然的使用它，同时它对我们是一个黑盒，一种抽象
//Complex.h
#pragma once
class Complex
{
public:
	Complex();			// 默认构造函数
	virtual ~Complex();	// 析构函数
};

//Complex.cpp
#include "Complex.h"
#include<iostream>
using namespace std;

Complex::Complex()
{
	cout << "Complex::Complex()" << endl;
}

Complex::~Complex()
{
	cout << "Complex::~Complex()" << endl;
}

//Test.cpp
#include <iostream>
#include "Complex.h"

int main()
{
	Complex c;
	return 0;
}

在这里插入图片描述

3 - 面向对象属性

//Complex.h
#pragma once
class Complex
{
public:
	Complex();			// 默认构造函数
	Complex(double r, double i);
	virtual ~Complex();	// 析构函数

	double GetReal() const;
	void SetReal(double d);
	double GetImage() const;
	void SetImage(double i);
private:
	double _real;          // 复数的实部
	double _image;         // 复数的虚部
};

//Complex.cpp
#include "Complex.h"
#include<iostream>
using namespace std;

Complex::Complex()
{
	cout << "Complex::Complex()" << endl;
}

Complex::Complex(double r,double i)
{
	this->_real = r;
	this->_image = i;
}

Complex::~Complex()
{
	cout << "Complex::~Complex()" << endl;
}

double Complex::GetReal() const { return _real; }
void Complex::SetReal(double d) { _real = d; }
double Complex::GetImage() const { return _image; }
void Complex::SetImage(double i) { _image = i; }

//Test.cpp
#include <iostream>
#include "Complex.h"

using namespace std;

int main()
{
	Complex c(1.0,2.0);
	cout << c.GetReal() << endl;	// 1
	cout << c.GetImage() << endl;	// 2
	c.SetReal(2.0);
	c.SetImage(3.0);
	cout << c.GetReal() << endl;	// 2
	cout << c.GetImage() << endl;	// 3

	return 0;
}

4 - +、=运算符重载

//Complex.h

#pragma once
class Complex
{
public:
	Complex();			// 默认构造函数
	Complex(double r, double i);
	virtual ~Complex();	// 析构函数

	double GetReal() const;
	void SetReal(double d);
	double GetImage() const;
	void SetImage(double i);

	// 运算符重载
	Complex operator+(const Complex& c);
	Complex& operator=(const Complex& c);
	Complex& operator+=(const Complex &c);


private:
	double _real;          // 复数的实部
	double _image;         // 复数的虚部
};

//Complex.cpp
#include "Complex.h"
#include<iostream>
using namespace std;

Complex::Complex()
{
	_real = 0.0;
	_image = 0.0;
}

Complex::Complex(double r, double i)
{
	this->_real = r;
	this->_image = i;
}

Complex::~Complex()
{
	cout << "Complex::~Complex()" << endl;
}

double Complex::GetReal() const { return _real; }
void Complex::SetReal(double d) { _real = d; }
double Complex::GetImage() const { return _image; }
void Complex::SetImage(double i) { _image = i; }

Complex Complex::operator+(const Complex& c)
{
	Complex tmp;
	tmp._real = _real + c._real;
	tmp._image = _image + c._image;
	return tmp;
}


Complex& Complex::operator= (const Complex& c)
{
	if (this != &c)
	{
		_real = c._real;
		_image = c._image;
	}
	return *this;
}

Complex& Complex::operator+= (const Complex& c)
{
	_real += c._real;
	_image += c._image;
	return *this;
}

//Test.cpp
#include <iostream>
#include "Complex.h"

using namespace std;

int main()
{
	Complex a(3.0, 2.0);
	Complex b(2.0, 3.0);
	Complex c;
	c = a + b;

	return 0;
}

5 - 前置后置操作符

//h
	// 前置和后置++
	Complex& operator++();   //前置++
	Complex operator++(int); //后置++
	Complex& operator--();   //前置--
	Complex operator--(int); //后置--

//cpp
Complex& Complex::operator++ () // 前置++
{
	_real++;
	_image++;
	return *this;
}

Complex Complex::operator++ (int) // 后置++
{
	//Complex tmp(*this);
	//_real++;
	//_image++;
	//return tmp;
	return Complex(_real++, _image++);
}

Complex& Complex::operator--()   //前置--
{
	_real--;
	_image--;
	return *this;
}

Complex Complex::operator--(int) //后置--
{
	return Complex(_real--, _image--);
}

//test
int main()
{
	Complex a(3.0, 2.0);
	Complex e;
	e = a++;
	e = ++a;

	return 0;
}

在这里插入图片描述

6 - 比较运算符重载

//h
	bool operator==(const Complex &c) const;
	bool operator!=(const Complex &c) const;

//cpp

bool Complex::operator==(const Complex& c) const
{
	return (_real == c._real) && (_image == c._image);
}

bool Complex::operator!=(const Complex& c) const
{
	return !( (_real == c._real) && (_image == c._image) );
}

二、拷贝构造

1 - 拷贝构造调用时机1

  • 调用拷贝构造的原因：tmp是内部定义的对象，在栈上，出了函数后就会被销毁，C++会自动调用拷贝构造函数
    在这里插入图片描述
  • 自己重写拷贝构造
//h
	Complex(const Complex& x);	// 拷贝构造

//cpp
Complex::Complex(const Complex& c)
{
	_real = c._real;
	_image = c._image;
	cout << "Complex::Complex(const Complex& c)" << endl;
}
  • 优化：避免产生临时对象，不调用拷贝构造
Complex Complex::operator+(const Complex& c)
{
	//Complex tmp;
	//tmp._real = _real + c._real;
	//tmp._image = _image + c._image;
	//return tmp;
	return Complex(_real + c._real, _image + c._image);
}
  • 优化 —— Complex c = a + b：可以非常明显的看到减少了1次构造与析构
    在这里插入图片描述

2 - 拷贝构造调用时机2

在这里插入图片描述

三、输入输出

1 - 类重载输入输出运算符

//h
#pragma once
#include <iostream>
using namespace std;

class Complex
{
public:
	Complex();			// 默认构造函数
	//省略...

	friend ostream& operator<<(ostream& os, const Complex& x);
	friend istream& operator>>(istream& is, Complex& x);

private:
	double _real;          // 复数的实部
	double _image;         // 复数的虚部
};

//cpp
ostream& operator<<(ostream& os, const Complex& x)
{
	os << "real value is  " << x._real << "  image value is " << x._image;
	return os;
}

istream& operator >> (istream& is, Complex& x)
{
	is >> x._real >> x._image;
	return is;
}

//test
#include <iostream>
#include "Complex.h"

using namespace std;

int main()
{
	Complex a(3.0, 2.0);
	Complex e;
	e = a++;
	cout << e << endl;
	e = ++a;
	cout << e << endl;

	cin >> e;
	cout << e << endl;

	return 0;
}

2 - IO流

  • 传统的C中的IO流：函数有printf、scanf、getch、gets等函数，它们存在问题
    • 不可编程，仅仅能识别固有的数据类型
    • 代码的可移植性差，有很多的坑
  • C++中的IO流：istream、ostream，它们的优点
    • 可编程，对于类库的设计者来说很有用
    • 简化编程，能使得I/O的风格一致

在这里插入图片描述

2 - IO缓存区

  • 标准IO提供的三种类型的缓存模式
    • ①.按块缓存：如文件系统
    • ②.按行缓存：\n
    • ③.不缓存

在这里插入图片描述

  • 缓冲区的验证
    • 使用清空缓存区脏数据的前后对比
      在这里插入图片描述

四、文件操作

1 - 文件介绍

  • 输入流的起点和输出流的终点：都可以是磁盘文件
  • C++中的文件：C++把每个文件都看成是一个有序的字节序列，每个文件都以文件结束标志结束
  • 按照文件中数据的组织形式可以把文件分为
    • 文本文件：文件中信息形式为ASCII码文件，每个字符占一个字节
    • 二进制文件：文件中信息的形式与其在内存中的形式相同
  • 文件操作步骤
    • ①.打开文件用于读或写open
    • ②.检查打开是否成功fail
    • ③.读或者写read，write
    • ④.检查是否读完EOF（end of file）
    • ⑤.使用完文件后关闭文件close
  • 文件打开方式
    • ios::in -> 打开文件进行读操作(ifstream默认模式)；
    • ios::out -> 打开文件进行写操作(ofstream默认模式)；
    • ios::ate -> 打开一个已有输入或输出文件并查找到文件尾；
    • ios::app -> 打开文件以便在文件的尾部添加数据；
    • ios::nocreate -> 如果文件不存在，则打开操作失败；
    • ios::trunc -> 如果文件存在，清除文件原有内容（默认）；
    • ios::binary -> 以二进制方式打开；

2 - 文本文件操作

  • 案例：文件流输入输出
#include <iostream>
#include "Complex.h"
#include <fstream>

using namespace std;

int main()
{
	int a;
	int index = 0;
	fstream fout;
	fout.open("testBuffer.txt", ios::app);
	//if (fout.fail()) //等价
	if (!fout)
	{
		cout << "open file failed" << endl;
	}
	while (cin >> a)
	{
		fout << "The numbers are: " << a << endl;
		index++;
		if (index == 5)
		{
			break;
		}
	}
	cin.ignore(numeric_limits<std::streamsize>::max(), '\n');  // 清空缓存区脏数据
	char ch;
	cin >> ch;
	fout << "the last char is: " << ch << endl;
	fout.close();
	return 0;
}

在这里插入图片描述

3 - 二进制文件操作

#include <iostream>
#include <fstream>

using namespace std;

static const int bufferLen = 2048;
bool CopyFile(const string& src, const string& dst)
{
	// 打开源文件和目标文件
	// 源文件以二进制读的方式打开
	// 目标文件以二进制写的方式打开
	ifstream in(src.c_str(), ios::in | ios::binary);
	ofstream out(dst.c_str(), ios::out | ios::binary | ios::trunc);

	// 判断文件打开是否成功，失败返回false
	if (!in || !out)
	{
		return false;
	}

	// 从源文件中读取数据，写到目标文件中
	// 通过读取源文件的EOF来判断读写是否结束
	char temp[bufferLen];
	while (!in.eof())
	{
		in.read(temp, bufferLen);
		streamsize count = in.gcount();//从最后一次读取的长度
		out.write(temp, count);
	}

	// 关闭源文件和目标文件
	in.close();
	out.close();

	return true;
}

int main()
{
	cout << CopyFile("Blue Daube.mp3", "Blue Daube2.mp3") << endl;
	return 0;
}

五、头文件重复包含问题

  • 为了避免同一个文件被include多次，有两种方式：使用宏、使用编译器
  • 方案1：使用宏来防止同一个文件被多次包含
    • 优点：可移植性好
    • 缺点：无法防止宏名重复，难以排错
#ifndef __SOMEFILE_H__
#defind __SOMEFILE_H__
...
#endif
  • 方案2：使用编译器来防止同一文件被多次包含：#pragma once
    • 优点：可以防止宏名重复，易排错
    • 缺点：可移植性不好
  • 总结使用：如果只在windows使用使用方案2，其他使用方案1（注意宏不要重名）

六、深拷贝、浅拷贝

  • 浅拷贝：只拷贝指针地址，C++默认拷贝构造函数与赋值运算符重载都是浅拷贝；节省空间，但容易引发多次释放

  • 深拷贝：重新分配堆内存，拷贝指针指向内容；浪费空间，但不会导致多次释放

  • h头文件

#pragma once
#include <iostream>
using namespace std;

class String
{
public:
	String(const char* str = NULL);				// 普通构造函数
	String(const String& other);                // 拷贝构造函数
	String(String&& other);                     // 移动构造函数
	~String(void);                              // 析构函数
	String& operator= (const String& other);    // 赋值函数
	String& operator=(String&& rhs)noexcept;	// 移动赋值运算符

	friend ostream& operator<<(ostream& os, const String& c); // cout输出

private:
	char* m_data; // 用于保存字符串
};
  • cpp实现
#include "String.h"


// _CRT_SECURE_NO_WARNINGS

// String 的普通构造函数
String::String(const char* str)
{
	if (str == NULL)
	{
		m_data = new char[1];
		if (m_data != NULL)
		{
			*m_data = '\0';
		}
		else
		{
			exit(-1);
		}
	}
	else
	{
		int len = strlen(str);
		m_data = new char[len + 1];
		if (m_data != NULL)
		{
			strcpy(m_data, str);
		}
		else
		{
			exit(-1);
		}
	}
}

// 拷贝构造函数
String::String(const String& other)
{
	int len = strlen(other.m_data);
	m_data = new char[len + 1];
	if (m_data != NULL)
	{
		strcpy(m_data, other.m_data);
	}
	else
	{
		exit(-1);
	}
}

// 移动构造函数
String::String(String&& other) //右值引用
{
	if (other.m_data != NULL)
	{
		// 资源让渡
		m_data = other.m_data;
		other.m_data = NULL;
	}
}


// 赋值函数
String& String::operator= (const String& other)
{
	if (this == &other)
	{
		return *this;
	}
	// 释放原有的内容
	delete[] m_data;
	// 重新分配资源并赋值
	int len = strlen(other.m_data);
	m_data = new char[len + 1];
	if (m_data != NULL)
	{
		strcpy(m_data, other.m_data);
	}
	else
	{
		exit(-1);
	}

	return *this;
}

// 移动赋值运算符
String& String::operator=(String&& rhs)noexcept
{
	if (this != &rhs)
	{
		delete[] m_data;
		m_data = rhs.m_data;
		rhs.m_data = NULL;
	}
	return *this;
}

// String 的析构函数
String::~String(void)
{
	if (m_data != NULL)
	{
		delete[] m_data;
	}
}

ostream& operator<<(ostream& os, const String& c)
{
	os << c.m_data;
	return os;
}
  • 测试类
#pragma once

#include "String.h"
using namespace std;


int main()
{

	String s1("Hello");			// 构造函数
	cout << s1 << endl;
	//String s2 = s1;			// 调用拷贝构造函数
	String s2(s1);				// 调用拷贝构造函数
	cout << s2 << endl;
	String s2A(std::move(s1));	// 移动构造函数
	cout << s2A << endl;
	String s3;					// 无参构造函数
	cout << s3 << endl;
	s3 = s2;					// 调用赋值函数
	cout << s3 << endl;
	String s3A;					// 无参构造函数
	s3A = std::move(s2A);		// 移动赋值运算符
	cout << s3A << endl;

	return 0;
}

七、虚函数

#include <iostream>
using namespace std;

// 抽象类
class Shape
{
public:
	virtual double Area() const = 0;// 子类方法实现不一致加上virtual
	virtual void Show() = 0;
	void SetColor(int color) { _color = color; }
	void Display()
	{
		cout << Area() << endl;
	}
private:
	int _color;
};

class Square : public Shape
{
public:
	Square(double len) :_len(len) { }
	void Show() { cout << "Square" << endl; }
	double Area() const
	{
		return _len * _len;
	}
private:
	double _len;
};


class Circle : public Shape
{
public:
	Circle(double radius) :_radius(radius) {}
	void Show() { cout << "Circle" << endl; }
	double Area() const
	{
		return 3.1415926 * _radius * _radius;
	}

private:
	double _radius;
};

class Triangle : public Shape
{
public:
	Triangle(double len, double height) :_len(len), _height(height) {}
	void Show() { cout << "Triangle" << endl; }
	double Area() const
	{
		return 0.5 * _len * _height;
	}

private:
	double _len;
	double _height;
};

int main()
{
	// 面对变化，尽可能少修改原有的逻辑，要扩充逻辑
	const int shapeNum = 3;

	Square s1(2.0);
	s1.SetColor(1);
	Circle   c1(2.0);
	Triangle t1(2.0, 3.0);

	Shape* shapes[shapeNum];
	shapes[0] = &s1;
	shapes[1] = &c1;
	shapes[2] = &t1;

	for (unsigned int index = 0; index < shapeNum; index++)
	{
		shapes[index]->Display();
	}

	cout << endl;
	cout << sizeof(s1) << endl;

	return 0;
}
无休止符
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 语法详解
04-03
C++语法详解》对C++的语法进行了全面介绍和深入讲解，内容包括：C++整型、字符型、浮点型、声明、定义、typedef、运算符、表达式、左值、选择语句、循环语句、指针、数组、函数和标识符的作用域、类基础、类作用域及...
算法工程师应该熟知的C++高级用法
lovely_yoshino的博客
11-21 7358
capture子句 参数列表(optional) 可变规范(optional) 异常定义(optional) 返回类型(optional) 函数体 1.2 即看即用 语法： 叫做捕获说明符参数列表表示返回类型，如果没有返回类型，则可以省略这部分。我们可以这样输出"hello,world" 变量捕获与lambda闭包实现 lambda函数能够捕获lambda函数外的具有自动存储时期的变量。函数体与这些变量的集合合起来叫闭包。 不截取任何变量 截取外部作用域中所有变量，并作为引用在函数体中使用 截取外部作
C++高级语法
turbolove的博客
05-29 1132
struct的默认成员权限是public，class的默认成员权限是private，除此之外二者基本没有差别。
c++高阶语法（一）
m0_63932570的博客
05-17 740
一）内联函数inline。解决函数调用的效率问题，在函数声明前加上inline即可，
C++语法[高级]
某某的博客
10-04 249
C++模板、C++常用查找、遍历、集合算法；容器：list、stack、queue、deque、vector等等
C++模板高级用法
晴天的专栏
09-09 2102
模板类A  有方法pop, 普通类B，有方法push,我把类B，作为一个类型传进类A， A.pop().push(), a.pop()返回的是a对象的引用，然后调用对象的方法a.pop().push(b)
c++核心语法
06-22
从入门开始讲解到c++高级编程MFC界面编程，核心c++操作，从而精通c++，同时注重分享职场常用知识点，让学员学有所获，学以致用。首先将C++的前生C语言的知识点，通过示例向同学们传授知识，同时以点带面的方式学员...
C++高级语法，调用函数接口，编程事半功倍
02-08
C++高级语法，调用函数接口，编程事半功倍
C++ 语法 高级版
02-25
c++ 语法 高级版 已经入门的朋友可以看看
常见的C++语法.rar
09-06
C++（c plus plus）是一种计算机高级程序设计语言，由C语言扩展升级而产生 [17] ，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。 C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为...
C++的高级用法
天方夜谭
01-12 1190
OpendTect C++中&（引用）高级用法 1.      引用： 别名(类似C中指针)，传址，避免整块数据压栈。 int a=34; int &ra = a;//ra即a的一个别名 cout cout void swap(int &p1, int &p2)  {         int p;  p = p1; p1= p2;    p2 = p; } int x =
C/C++ 控制台高级操作(非常详细)
热门推荐
余识-
03-14 1万+
C/C++ 修改控制台(黑窗口)的颜色,大小,光标,标题等方法,详细介绍各种API函数使用介绍,以及对应的官方文档
C++高级编程 -知识点笔记（自用）
Dijkstraand的博客
11-29 1958
C++高级编程，课程笔记，自己复习用
C语言的高级用法
zhen
11-12 1322
c语言
java的类加载顺序
Code-S
05-09 430
public class InitDemo extends FatherClass { { System.out.println("子类-->非静态代码块"); } DemoClass d5 = new DemoClass("子类-->成员变量d5"); static DemoClass d4 = new DemoClass("子类-->静态成员变量d4"
c++11高级用法（建议收藏）
qq_56999918的博客
11-12 1237
2.会导致资源延迟释放weak_ptr 会保持控制块(强引用, 以及弱引用的信息)的生命周期, 而因此连带着保持了对象分配的内存, 只有最后一个 weak_ptr 离开作用域时, 内存才会被释放. 原本强引用减为 0 时就可以释放的内存, 现在变为了强引用, 弱引用都减为 0 时才能释放, 意外的延迟了内存释放的时间. 这对于内存要求高的场景来说, 是一个需要注意的问题.我们再前面说过这个这个创建一个线程之后，创建它的这个线程需要调用join方法进行等待，对线程资源进行回收此时这个线程也会被阻塞再这里。
c++高阶语法（三）
m0_63932570的博客
05-22 521
今天，我们来分享c++语法中的关键字，在c++学习中，关键字有很多，如const，static，enum等等。 下面是c++语法中的全部关键字（好像是73个） 大部分在基础语法学习中的已经见过了，现在我们来看看几个不常见又有时候起关键作用的关键字吧。 1.char、wchar_t 表示字符型和宽字符型这些整数类型（属于基本类型），但一般只专用于表示字符。char（和signed char、unsigned char一起）事实上定义了字节的大小。char表示单字节字符，wchar_t表示多字节字符
c++高级语法 算法
最新发布
12-30
C高级语法算法是指在使用C语言进行编程时，使用更加复杂和高级的语法结构和算法技巧来解决问题和优化程序性能。 其中，高级语法主要包括以下几个方面： 1. 指针运算：指针是C语言的重要概念，高级语法中可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

无休止符

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值