C++ 基础笔记

最新推荐文章于 2024-05-16 18:50:49 发布

置顶少年丶趁年轻

最新推荐文章于 2024-05-16 18:50:49 发布

阅读量499

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/qq_27726651/article/details/96299777

版权

C++ 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

主要记录c++的学习笔记：

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

Tips:

空类所占字节数为1
类中的成员函数不占内存空间。【虚函数除外,虚函数实质是指针，占用4字节】
和结构体一样,类中自身带有四字节对齐功能
类中的static静态成员变量不占内存,静态成员变量存储在静态区

抽象类：c++规定，含有纯虚函数的类叫做抽象类，它不能实例化对象；【抽象类主要是抽象出一系列行为，但不做具体分析，分析交由派生类去实现具体行为】
纯虚函数：不能对虚函数给出有意义的实现，一般写为 virtual void func() = 0；

/*----------------------------------------------------------------------------------------------------*/

1. 继承

1.1 继承的基本概述

继承的语法：class 子类：继承方式父类，例如 class son : public father

继承的方式：

公共继承
保护集成
私有继承

下面通过一张图展示继承后的访问权限关系：

由上图可知，父类为 A，子类为 B，父类中的private 成员，子类无论使用哪种继承，均不可访问

公共继承：父类的public和protected属性，子类继承过来也是public和protected属性，private不可访问

保护继承：父类中的public和protected属性，继承到子类后都为protected属性，private不可访问

私有继承：父类中的public和protected属性，继承到子类后都为private属性，private不可访问

1.2 继承的对象模型

通过sizeof查看派生类的大小，可知继承中，究竟有哪些成员会被继承过去：

class Father {
public:
	int m_A;
	static int m_D; //父类的静态成员不会被子类继承
protected:
	int m_B;
private:
	int m_C;

};

class Son : public Father
{
public:
	int m_E;
};

int main()
{	
	Son s1;
	cout << "s1的大小为：" << sizeof(s1) << endl;  
}

//打印结果为16，静态成员不会被子类继承
//private虽然不能被子类访问，但是也被继承过来了

程序运行后，打印结果为16，其中静态成员不会被子类继承
而 private虽然不能被子类访问，但是也被继承过来了

1.3 继承中的构造和析构顺序

当创建子类对象时，子类所继承的父类对象也会被先创建

继承中，先调用父类构造函数，再调用子类构造函数，而析构时与之相反。

1.4 菱形继承

下图是典型的菱形继承图：

其中，羊继承了动物类，驼也集成了动物类，然后草泥马又集成了羊和驼。比如羊类和驼类中都含有m_Age成员，那么草泥马又继承了哪个m_Age成员呢？请看下面的代码：

class Animal {
public:
	int m_Age;
};
class Sheep : public Animal   //羊继承了动物类
{
};
class Camel : public Animal   //驼继承了动物类
{
};
class Sheep_Camel :public Sheep, public Camel //草泥马继承了羊和驼2个类
{
};

int main()
{	
	Sheep_Camel yang_tuo;
	yang_tuo.Sheep::m_Age = 28; //通过父类名来区分m_Age成员
	yang_tuo.Camel::m_Age = 18; //通过父类名来区分m_Age成员
//从上面看出，菱形继承导致年龄成员出现了2份，而实际只需要1份，造成了资源浪费
}

从以上可知，虽然我们通过类名解决了成员重名的问题，但是菱形继承却出现了2个相同的成员名称，这不是我们想要的。为了解决菱形继承中的成员重复问题，我们可以引入虚继承。就是在继承前加个virtual关键字，如下代码。

class Animal {
public:
	int m_Age;
};
class Sheep : virtual public Animal //继承时，前面加上virtual关键字
{
};
class Camel : virtual public Animal //继承时，前面加上virtual关键字
{
};
class Sheep_Camel :public Sheep, public Camel
{
};


int main()
{	
	Sheep_Camel yang_tuo;
	yang_tuo.Sheep::m_Age = 28;
	yang_tuo.Camel::m_Age = 18;
	cout << "yang_tuo的年龄为：" << yang_tuo.Sheep::m_Age << endl;
//这样不管是从羊还是从驼身上继承过来，结果都只有1个m_Age
}

以上打印出来的m_Age为18，因为加上virtual虚拟继承后，就只有1个m_Age了，这样完美解决了菱形继承中的资源浪费问题

1. 5虚拟继承（virtual）

虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。

2. 构造函数 & 析构函数 & 初始化列表

构造函数：

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初值。

析构函数：

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

下面的实例有助于更好地理解构造函数的概念：

class python
{
private:
    char *name;
    int  age;
    char *work;

public:
    python(); //无参构造函数
    ~python(); //析构函数
    python(char *name,int age,char *work); //带参构造函数
    print_info();
};

python::python()  //在创建类的对象时，会被自动调用此构造函数
{
    cout<<"Object is being created\n"<<endl;
}

python::~python() //在函数返回之前，默认会执行此析构函数以释放资源
{
    cout<<"Object is delete\n"<<endl;
}

int main(int argc, char *argv[])
{
    python Py; //创建类的对象时，会自动调用构造函数
    cout << "Hello World!" << endl;
    return 0;
                //在该函数返回之前，会自动执行析构函数
}

函数执行结果如下：

从上面的打印结果看出，在创建完类的对象Py时，自动调用了构造函数 python::python()

在函数返回前，又会自动调用析构函数 python:: ~python()

2.1 初始化列表

给类的成员变量赋初值除了之前那种方式外，还有初始化列表的方式，如下：

/* 第1种 */
class cube {
private:
	int m_A;
	int m_B;
	int m_C;

public:
	cube():m_A(10), m_B(20), m_C(30)  //通过初始化列表的方式给成员赋初值，但是值被写死了
	{

	}

};


/* 第2种 */
class cube {
private:
	int m_A;
	int m_B;
	int m_C;

public:
	cube(int a,int b,int c):m_A(a), m_B(b), m_C(c)  //通过初始化列表传参的方式给成员赋初值
	{

	}

};

3. 多态

3.1 多态的基本概念

c++多态分为2类：

静态多态：函数重载 & 运算符重载，他们特点都是重用了函数名
动态多态：派生类 & 虚函数实现运行时多态

静态多态和动态多态的区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行时确定函数地址

3.2 动物和狗说话实例【virtual用法】

若要想执行动态多态，实现地址晚绑定，只需要在基类的方法前面加上virtual关键字即可。

从下面例子可以看出，明明传入的参数是Dog对象，执行的确实Animal的函数：

#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
	void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Dog : public Animal
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

void DoSpeak(Animal& animal) //地址早绑定，编译阶段，地址便已确定
{
	animal.speak();
}

int main()
{	
	Dog dog;
	DoSpeak(dog); //传入的Dog类，结果打印出来发现执行的是"动物在说话"

	system("pause");
	return 0;
}

上例中，由于DoSpeak(Animal &animal) 方法，在编译阶段，地址就已确定，所以在传入Dog对象时出错。

所以，如果要执行“小狗在说话”，那么这个函数就不能提前绑定，需要在运行阶段进行绑定，也就是地址晚绑定。

那么怎么实现在运行阶段进行晚绑定呢？答案就是在基类的方法前面加上virtual关键字即可。如下所示：

class Animal {
public:
	virtual void speak() //加上virtual，动态多态，实现地址运行时绑定
	{
		cout << "动物在说话" << endl;
	}
};

总结：

要实现动态多态，需要满足一下条件：

有继承关系
子类重写父类的虚函数 （ps.子类重写时，virtual关键字可写可不写，不影响）

动态多态的使用：

父类的指针或者引用，指向子类的对象

3.3 动态多态 & 虚函数【实例2】

基类的指针也可以指向派生类对象，请看下面的例子：

 #include <iostream>
using namespace std;
//基类People
class People
{
protected:
    char *m_name;
    int m_age;

public:
    People(char *name, int age): m_name(name), m_age(age){}
    void display()
    {
        cout<<m_name<<"今年"<<m_age<<"岁了，是个无业游民。"<<endl;
    }

};

//派生类Teacher
class Teacher: public People
{
private:
    int m_salary;

public:
    Teacher(char *name, int age, int salary): People(name, age), m_salary(salary){}
    void display()
    {
        cout<<m_name<<"今年"<<m_age<<"岁了，是一名教师，每月有"<<m_salary<<"元的收入。"<<endl;
    }
};

int main(){
    People *p = new People("王志刚", 23);
    p -> display();
    p = new Teacher("赵宏佳", 45, 8200);  //此时，基类指针指向了派生类
    p -> display();
    return 0;
}

运行结果：
王志刚今年23岁了，是个无业游民。
赵宏佳今年45岁了，是个无业游民。

我们直观上认为，如果指针指向了派生类对象，那么就应该使用派生类的成员变量和成员函数，这符合人们的思维习惯。但是本例的运行结果却告诉我们，当基类指针 p 指向派生类 Teacher 的对象时，虽然使用了 Teacher 的成员变量，但是却没有使用它的成员函数，导致输出结果不伦不类（赵宏佳本来是一名老师，输出结果却显示人家是个无业游民），不符合我们的预期。

换句话说，通过基类指针只能访问派生类的成员变量，但是不能访问派生类的成员函数。

为了消除这种尴尬，让基类指针能够访问派生类的成员函数，C++ 增加了虚函数（Virtual Function）。使用虚函数非常简单，只需要在函数声明前面增加 virtual 关键字。
更改上面的代码，将 display() 声明为虚函数：

运行结果：
王志刚今年23岁了，是个无业游民。
赵宏佳今年45岁了，是一名教师，每月有8200元的收入。

和前面的例子相比，本例仅仅是在 display() 函数声明前加了一个virtual关键字，将成员函数声明为了虚函数（Virtual Function），这样就可以通过 p 指针调用 Teacher 类的成员函数了，运行结果也证明了这一点（赵宏佳已经是一名老师了，不再是无业游民了）。

有了虚函数，基类指针指向基类对象时就使用基类的成员，指向派生类对象时就使用派生类的成员（包括成员函数和成员变量）。换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为多态（Polymorphism）。

上面的代码中，同样是p->display();这条语句，当 p 指向不同的对象时，它执行的操作是不一样的。同一条语句可以执行不同的操作，看起来有不同表现方式，这就是多态。

多态是面向对象编程的主要特征之一，C++中虚函数的唯一用处就是构成多态。

C++提供多态的目的是：可以通过基类指针对所有派生类（包括直接派生和间接派生）的成员变量和成员函数进行“全方位”的访问，尤其是成员函数。如果没有多态，我们只能访问成员变量。
前面我们说过，通过指针调用普通的成员函数时会根据指针的类型（通过哪个类定义的指针）来判断调用哪个类的成员函数，但是通过本节的分析可以发现，这种说法并不适用于虚函数，虚函数是根据指针的指向来调用的，指针指向哪个类的对象就调用哪个类的虚函数。
但是话又说回来，对象的内存模型是非常干净的，没有包含任何成员函数的信息，编译器究竟是根据什么找到了成员函数呢？我们将在《C++虚函数表精讲教程，直戳多态的实现机制》一节中给出答案。

该章节参考自：http://c.biancheng.net/view/2294.html

3.4 virtual虚函数实质

每个类都有一块叫做vftable的虚函数表，当在Animal类中定义了一个虚函数之后，其实质是在该表中定义了一个指针。如下图：

当子类重写父类的虚函数时，子类中的虚函数表内部会将父类的指针替换成子类虚函数表的指针，如下图：

Q：请问为什么加上virtual关键字后，就可以实现多态？

A：因为每个类里面都有一个虚函数表，当子类重写父类的虚函数时，会将父类的虚函数表指针替换成子类的虚函数表指针。

下面展示一个制作饮品的抽象类实现Demo

#include <iostream>

using namespace std;

class Drinking {      //抽象类

public:
    virtual void Boil() = 0;
    virtual void Brew() = 0;
    virtual void PourInCup() = 0;
    virtual void PutSomething() = 0;

    void makeDrink()
    {
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};

class Coffee : public Drinking
{
public:
    void Boil()
    {
        cout << "煮农夫山泉" << endl;
    }
     void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
     void PourInCup()
    {
        cout << "倒入杯中" << endl;
    }
     void PutSomething() 
    {
        cout << "加入糖" << endl;
    }
};

class Tea : public Drinking
{
public:
    void Boil()
    {
        cout << "煮矿泉水" << endl;
    }
    void Brew()
    {
        cout << "冲泡茶叶" << endl;
    }
    void PourInCup()
    {
        cout << "倒入玻璃杯" << endl;
    }
    void PutSomething()
    {
        cout << "加入枸杞" << endl;
    }
};

void do_work(Drinking *drink) 
{
    drink->makeDrink(); //根据传入的不同参数，调用不同的实现
    delete drink;
}


int main()
{
    cout << "++++ 制作咖啡 ++++" << endl;
    do_work(new Coffee);
    cout << "++++ 制作茶叶 ++++" << endl;
    do_work(new Tea);
    std::cout << "Hello World!\n";

}

4. 拷贝构造函数用法

c++在对类实例化对象时，会默认创建3个函数：

默认构造函数
默认析构函数
默认拷贝构造函数

个人理解，拷贝构造函数是用于给对象之间赋值用的。

class person
{
private:
    char *name;
    int  age;
    char *work;

public:
    person(); //无参构造函数
    ~person(); //析构函数
    person(char *name,int age,char *work); //带参构造函数

/* 下面这个拷贝构造函数可以不写，编译器会自动实现 */
    person(const person & p) //拷贝构造函数
    {
        cout<<"拷贝构造函数调用"<<endl;
        name = p.name;
        age = p.age;
        work = p.work;
    }
    print_info()
    {
        cout<<"name:"<<name<<"\n age:"<<age<<"\n work:"<<work<<endl;
    }
};

用法如下：

int main(int argc, char *argv[])
{
    person Py1("LiuM",28,"Engineer");
    person Py2(Py1); //新的对象通过拷贝构造函数获取对象Py1的内容
    Py2.print_info();
    cout << "Hello World!" << endl;
    return 0;
}

编译如下：

通过以上打印执行信息可以看到，Py2成功拷贝了Py1的信息。

4.1 浅拷贝和深拷贝

浅拷贝：简单的赋值操作。

深拷贝：在堆区重新申请空间，进行拷贝操作。

示例参考： c++深拷贝与浅拷贝实例

c++ 引用

(1) 什么是引用

引用是c++里面所特有的功能，它实际就是给一个变量起别名，其格式为：类型 &别名 = 原名例如：

int a = 10;
int &b = a;  //给变量a起一个别名为b

(2) 引用的使用场景

(2.1) c++中的引用更多的是用来作函数传参和函数返回值，说到函数传参，现在列举下有哪些函数传参方式：

值传递
地址传递
引用传递

下面通过代码演示这3中传递：


void Swap_01(int a, int b)  /* 值传递 */
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}

void Swap_02(int *a, int *b)  /* 地址传递 */
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

void Swap_03(int &a, int &b)  /* 引用传递 */
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}

int main()
{
	cout << "Hello World\n" << endl;	

	int a = 10;
	int b = 20;

	//Swap_01(a, b);  // 值传递
	//Swap_02(&a, &b);// 地址传递
	Swap_03(a, b);    // 引用传递

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;

	system("pause");
	return 0;
}

切记，引用在声明时，必须赋初值，例如：

int &temp; //没赋初值，错误的用法

int &temp = 10; //正确用法

(2.2) 引用做函数返回值

#include <iostream>
using namespace std;

/* 引用传递 */
int& Swap_03()
{
	static int a = 10;
	return a;
}

int main()
{	
	int& temp = Swap_03();

	cout << "temp= " << temp << endl;

	Swap_03() = 1000; //如果函数返回值是引用，那么这个函数调用可以作左值
	cout << "temp= " << temp << endl;

	system("pause");

	return 0;
}

以上函数执行结果如下：【分析执行结果发现，引用可以当做指针使用】

(2.3) 引用的本质

引用的本质是一个指针常量。

int &ref = a; //编译器自动将其转换为： int * const ref = &a;

ref = 20; //编译器发现ref为引用，自动将其转换为 *ref = 20;

指针常量 & 常量指针

(1) 概念

const 修饰指针，叫做常量指针。例如：

int a = 10;
int b = 20;

const int *p = &a; //常量指针

p = &b; //正确，指针的指向可以修改
*p = 20; //错误，指针指向的值不可以修改

常量指针特点：指针的指向可以修改，但是指向的值不可以修改

指针修饰const值，叫做指针常量。例如：

int a = 10;
int b = 20;

int* const p = &a; //指针常量

*p = 20; // 正确，值可以修改
 p = &b; // 错误，指针的指向不可以修改

const 即修饰指针，又修饰常量。例如：

int a = 10;
int b = 20;

const int* const p = &a;

p = &b;  //错误，因为const修饰了指针，所以指向不能变
*p = 20; //错误，因为const也修饰了常量，所以值也不能修改

运算符重载 [operator]

概念：

运算符重载：就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

格式：operator + "运算符符号"，例如 operator+

1. 加法运算符重载

例如：有2个类，p1和p2，如果要实现这2个类里面的成员变量相加，执行 p1 + p2 会报错，因为编译器并不识别。

因此就需要对操作符进行重新定义如下示例：

这里先说明一下，重载有2种写法：成员函数类型 & 全局函数类型，这里介绍的是成员函数类型的重载。

#include "Operator.hpp"
#include <iostream>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

class Operator
{
public:
    int m_Val_1;
    int m_Vla_2;
    
    Operator operator+(Operator &a) //重载 + 号运算符
    {
        Operator temp;

        temp.m_Val_1 = this->m_Val_1 + a.m_Val_1;
        temp.m_Vla_2 = this->m_Vla_2 + a.m_Vla_2;
        return temp;
    }
    Operator operator+(int b)  //operator的重载
    {
        Operator temp;

        temp.m_Val_1 = this->m_Val_1 + b;
        temp.m_Vla_2 = this->m_Vla_2 + b;
        return temp;
    }
};

int main(void)
{
    Operator p1;
    p1.m_Val_1 = 1;
    p1.m_Vla_2 = 2;

    Operator p2;
    p2.m_Val_1 = 3;
    p2.m_Vla_2 = 4;

    Operator p3 = p1.operator+(p2);
    cout << "p3.m_Val_1 = " << p3.m_Val_1 << endl;
    cout << "p3.m_Val_2 = " << p3.m_Vla_2 << endl;

    cout << endl;

    Operator p4 = p1 + p2;
    cout << "p4.m_Val_1 = " << p4.m_Val_1 << endl;
    cout << "p4.m_Val_2 = " << p4.m_Vla_2 << endl;

    cout << endl;

    Operator p5 = p1 + 10; //运算符 int重载
    cout << "p5.m_Val_1 = " << p5.m_Val_1 << endl;
    cout << "p5.m_Val_2 = " << p5.m_Vla_2 << endl;

    system("pause");
    return 0;
}

从打印结果可以看出，通过operator+ 成员函数，成功实现了 p1+ p2 的过程，并拓展实现了 p1 + int 型的重载；

2. “<<” 运算符重载

<< 运算符重载只能写成全局函数类型的，因为成员函数类型的只能传1个参数，示例如下：

#include "Operator.hpp"
#include <iostream>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

class OperatorLeftShift
{
    public:
    int m_Val_1;
    int m_Val_2;
};

void operator<<(ostream &cout, OperatorLeftShift &p)
{
    cout << "m_Val_1 = " <<p.m_Val_1<<"\nm_Val_2 = " << p.m_Val_2;
}

int main(void)
{

    OperatorLeftShift p6;
    p6.m_Val_1 = 10;
    p6.m_Val_2 = 20;
    cout << p6;

    system("pause");
    return 0;
}

虚析构和纯虚析构

情景：多态在使用时，如果子类有属性开辟到堆区，那么父类的指针在释放时无法调用到子类的析构代码。

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要具体的函数实现

虚析构和纯虚析构的区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构典例：

下面是一段，多态中，由于没有虚析构，导致派生类内存没有被释放干净的情况例子：

#include "Operator.hpp"
#include <iostream>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

class Animal{

    public:
        virtual void speak() = 0;

        ~Animal()  //未使用虚析构
        {
            cout << "Animal的析构函数" << endl;
        }
};

class Dog : public Animal
{
    public:
    void speak()
    {
        cout << *m_name<<"小狗在说话" << endl;
    }

    string *m_name;
    Dog(string name)
    {
        cout << "Dog's construct is called" << endl;
        m_name = new string(name); //派生类在堆上面申请了内存
    }
    ~Dog()
    {
        cout << "Dog的析构函数调用" << endl;
        if(m_name != NULL)
        {
            delete m_name;
            m_name = NULL;
        }
    }
};

int main(void)
{
    Animal *p = new Dog("xiaoming");
    p->speak();
    delete p;

    system("pause");
    return 0;
}

打印结果发现，Dog类中new出来的对象并没有进行释放，导致内存泄漏；

解决方法：

只需要将Animal类中的析构函数前面加上 virtual 关键字即可成为虚析构，从而可以解决派生类的内存没有释放问题；

如下所示：

纯虚析构典例：

我们知道纯虚函数写法，就是将带 virtual 的函数体实现去掉，并=0；如 virtual void speak() = 0;

那么，纯虚析构写法也是相同的，如：virtual ~Animal() = 0; But.. , 纯虚析构与纯虚函数不同的是：纯虚析构不仅有声明，还必须在类外有实现，如下所示：

说明：即便只有纯虚析构，那么它也是抽象类，不能实例化对象；

总结：

虚析构或纯虚析构就是用来解决父类指针释放子类对象
如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
拥有纯虚析构函数的类也属于抽象类

文件IO

c++对文件操作需要包含头文件 <fstream>

文件类型分为两种：

文本文件 -文件以文本的asc方式存储在计算机中
二进制文件 - 文件以文本的二进制方式存储在计算机中，用户一般不能直接读懂

操作文件的3个大类：

ofstream: 写操作
ifstream: 读操作
fstream: 读写操作

写文件流程：

包含头文件 #include <fstream>
创建流对象 ofstream ofs;
打开文件 ofs.open("文件路径", 打开方式)；
写数据 ofs << "写入的数据"；
关闭文件 ofs.close();

文件的打开方式：

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在，先删除再创建
ios::binary	二进制方式

注意：文件的打开方式可以配合操作；

例如：用二进制写文件， ios::binary | ios::out

下面是一段向txt文件内写入一串字符的例子：

#include <fstream> //包含头文件

using namespace std;

int main(void)
{
    ofstream fs; //创建流对象
    fs.open("C:/Users/LiuMing/Desktop/temp/test.txt", ios::out|ios::app);
    fs<<"  test\n";
    fs<<"  abc\n";
    fs.close();

    system("pause");
    return 0;
}

STL 简介

STL （Standard Template Library, 标准模板库）
STL从广义上分为：容器（Container）、算法(algorithm)、迭代器（iterator）
容器和算法之间通过迭代器进行无缝衔接
STL几乎所有代码都是用了模板类或者模板函数

STL 六大组件

STL大体分为六大组件，分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

vector 封装了数组
list 封装了链表
map 和 set 封装了二叉树等

以上的区别，可参考CSDN博客： https://blog.csdn.net/caojunhao123/article/details/11907857

容器vector使用

#include <iostream>
#include <cstdlib>
#include <vector>
#include <algorithm>

using namespace std;

int main(void)
{
    vector<int> v1; //定义一个容器

    for (int i = 0; i < 5;i++)
    {
         v1.push_back(5-i);  //插入容器内
    }

    sort(v1.begin(), v1.end());  //从小到大排序

    for (auto it = v1.begin(); it != v1.end();it++)
        cout << *it << endl;  //输出容器的数值

    system("pause");
    return 0;
}

C++模板

c++的另一种编程思想是“泛型编程”，所用到的技术就是“模板”
c++提供两种模板机制

函数模板
类模板

1. 函数模板的语法

函数模板的作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。

语法格式：

//函数声明或定义
template<typename T>

//或者
template<class T>

解释：
template -- 声明创建模板
typename -- 表示其后面的符号是一种数据类型，可以用class来代替
T -- 通用的数据类型，名称可以替代，通常为大写字母

请看下面一个实例：

现在需要做2个数的交换操作，但是这2个数的数据类型不确定，实现方法如下：

/* 交换两个整形 */
void swapInt(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}

/* 交换两个浮点型 */
void swapFloat(float& a, float& b)
{
    float temp = a;
    a = b;
    b = temp;
}

/* 交换两个双浮点型 */
void swapFloat(double& a, double& b)
{
    doubletemp = a;
    a = b;
    b = temp;
}

... ...

上面的示例可以看出，如果有1万中数据类型，则要写1万个交换函数，十分繁琐。
这时候，函数模板就派上用场了！

使用函数模板改进上述示例，如下：

template<typename T>
void Swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

/* 示例1：自动类型推导 */
int main()
{
    int a = 10;
    int b = 20;
    Swap(a, b);  //自动类型推导
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

/* 示例2：显式指定类型 */
int main()
{
    int a = 10;
    int b = 20;
    Swap<int>(a, b);  //显式指定类型
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

从上例可以看出，只需要使用"T"就可以解决数据类型不确定的问题，使代码变得简单方便。

C++11笔记

Lambda 表达式

精学参见侯捷视频：https://www.bilibili.com/video/BV1Bt411G7kc?p=14

1. 基本写法

lambda就是一个类似 inline 的函数，可以当做参数来使用。
写法格式如下：

[] { std::cout << "Lambda" << std::endl; };

它只可以被当做参数来调用，如果要直接运行它，可以加个(), 如下所示：

[] { std::cout << "Lambda" << std::endl; }();

或者写成：

/* 我们无法知道Lambda的类型，所以用auto代替 */
auto F = [] { std::cout << "Lambda" << std::endl; };
F();

/* 如果还要传参，写法如下 */
auto F = [](int param){
    param++;
    std::cout<< param << std::endl;
}

F(7);
F(9);

2. 参数用法：

通过“值传递” [=] 或者“引用传递”[&] 来引用外部变量，如下：

/* 通过引用传递，将a传递进函数体内 */
int a = 10;
[&a] {
     std::cout << a << std::endl; 
   };

/* 通过值传递，将a传递进函数体内 */
int a = 10;
[=] {
     std::cout << a << std::endl; 
   };

/* 如果要改变a的值，则需要引入 mutable 关键字
   同时，[]后面需要加上()     */
int a = 10;
[&a]() mutable {
     a++;
     std::cout << a << std::endl; 
   };

C++设计模式

单例模式

一个类有且只能实例化“1”个对象

要点：

类构造函数私有，析构函数公有
持有自己类型的属性
对外提供获取实例的静态方法

少年丶趁年轻

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
C++ 基础笔记

主要记录c++的学习笔记：/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/Tips:空类所占字节数为1 类中的成员函数不占内存空间。【虚函数除外,虚函数实质是指针，占用4字节】和结构体一样,类中自身带有四字节对齐功能类中的static静态成员变量不占内存,静态成员变量存储在静态区/*----...
复制链接

扫一扫