孤城飞雁
孤城飞雁

C++学习笔记

本文为学习C++时做的笔记，参考视频为bilibili的黑马程序员的C++入门教程

一、面向对象

1. 对象的初始化和清理

1.1 深拷贝浅拷贝

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

  • 带来的问题： 堆区内存重复释放

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

class Person {
public:
	Person()
	{
		cout << "Person 默认构造函数调用" << endl;
	}

	Person(int age, int height)
	{
		m_Age = age;
        //属性m_Height在堆区开辟
		m_Height = new int(height);
		cout << "Person 有参构造函数调用" << endl;
	}

	Person(const Person& p)
	{
		m_Age = p.m_Age;
		m_Height = new int(*p.m_Height);
		cout << "Person 拷贝构造函数调用" << endl;
	}

	~Person()
	{
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
		cout << "Person 析构函数调用" << endl;
	}

	int m_Age;
	int* m_Height;
};

void test01()
{
	Person p1(18, 160);

	cout << "p1的年龄：" << p1.m_Age << "p1身高为：" << *p1.m_Height << endl;

	Person p2(p1);
	cout << "p2的年龄：" << p2.m_Age << "p2身高为：" << *p2.m_Height << endl;
}

总结： 如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

1.2 初始化列表

作用： C++提供了初始化列表语法，用来初始化属性

class Person {
public:
	//初始化列表属性
	Person(int a, int b, int c):m_A(a),m_B(b),m_C(c)
	{
		cout << "Person 有参构造函数调用" << endl;
	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p(10, 20, 30);
}

1.3 类对象作为类成员

类中的成员可以是另一个类的对象

class A {}
class B
{
    A a;
}

B类中有对象A作为成员，A作为对象成员。

先构造A,再构造B。析构与构造顺序相反

1.4 静态成员

静态成员分为：

  • 静态成员变量
    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量(不能访问非静态成员变量，无法区分到底是哪个对象的变量)
class Person
{
public:
	//1.所有对象都共享同一份数据
	//2.编译阶段就分配内存
	//3.类内声明，类外初始化操作
	static int m_A;

	//静态成员变量也是有访问权限的
private:
	static int m_B;
};

int Person::m_A = 100;
int Person::m_B = 200;

void test01()
{
	Person p;
	cout << p.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << p.m_A << endl;
}

void test02()
{
	//静态成员变量不属于某个对象上，所有对象都共享同一份数据
	//1.通过对象进行访问
	Person p;
	cout << p.m_A << endl;
	//2.通过类名进行访问
	cout << Person::m_A << endl;
}

2. C++对象模型和this指针

2.1 成员变量和成员函数分开存储

在c++中，类的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

注：

  1. c++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置，即每个空对象也应有一个独一无二的内存地址
  2. 静态成员变量，不属于类对象上
  3. 非静态成员函数，不属于类对象上
  4. 静态成员函数，不属于类的对象上

2.1 this指针概念

this指针的作用： 指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的用途：

  • 当形参和成员变量同名时，可用this指针来区分
  • 在类的非静态成员函数中返回对象本身，可使用return *this
class Person
{
public:
	Person(int age)
	{
		this->age = age;
	}

	Person& PersonAddAge(Person &p)
	{
		this->age += p.age;

		//this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}

	int age;
};

void test01()
{
	Person p = Person(18);

	cout << "p1的年龄为：" << p.age << endl;
}

void test02()
{
	Person p1(10);
	Person p2(10);

	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}

2.2 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

class Person
{
public:
	
	void showClassName()
	{
		cout << "this is Person class" << endl;
	}

	void showPersonAge()
	{
		if (this == NULL)
			return;
		//报错原因是因为传入的指针为NULL
		cout << "age = " << this->m_Age << endl;
	}

	int m_Age;
};

void test01()
{
	Person* p = NULL;

	//p->showClassName();
	p->showPersonAge();
}

2.3 const 修饰成员函数

常函数：

  • 成员函数后加const后我们称这个函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加 const称该对象为常对象
  • 常对象只能调用常函数
#include
using namespace std;

class Person
{
public:
	//this指针的本质是指针常量，指针的指向是不可以修改的
	//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
	void showPerson() const
	{
		this->m_Age = 100;	//不可修改
		this->m_B = 100;
	}
	
	void func()
	{

	}

	int m_Age;
	mutable int m_B;	//加了关键字mutable之后，即使在常函数中，也可以修改这个值
};

//常对象
void test02()
{
	const Person p;	//在对象前加const，变为常对象
	//p.m_Age = 100;
	p.m_B = 100;	//m_B是特殊值，在常对象下也可以修改
	p.func();	//常对象 不可以调用普通成员函数，因为普通成员函数可以修改属性
}

3. 友元

友元关键字为friend

友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元

3.1 全局函数做友元

class Building
{
	//goodGay全局函数是Building的朋友，可以访问Building中私有成员
	friend void goodGay(Building* building);
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;

private:
	string m_BedRoom;
};

//全局函数
void goodGay(Building *building)
{
	cout << "好基友全局函数正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友全局函数正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
	Building building;
	goodGay(&building);
}

3.2 类做友元

class Building;

class GoodGay
{
public:
	GoodGay();

	void visit();	//参观函数，访问Building种的属性
	Building* building;
};

class Building
{
	friend class GoodGay;
public:
	Building();
public:
	string m_SittingRoom;

private:
	string m_BedRoom;
};
//类外写成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "好基友正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
	GoodGay gg;
	gg.visit();
}

3.3 成员函数做友元

class GoodGay
{
public:
	GoodGay();

	void visit();	//让visit函数可以访问Building中私有成员
	void visit2();	//让visit函数不可以访问Building中私有成员
	Building* building;
};

class Building
{
	//Goodgay类下的visit成员函数作为本类的好朋友，可以访问私有成员
	friend void GoodGay::visit();
public:
	Building();
public:
	string m_SittingRoom;

private:
	string m_BedRoom;
};
//类外写成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "好基友正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友正在访问：" << building->m_BedRoom << endl;
}

void GoodGay::visit2()
{
	cout << "好基友正在访问：" << building->m_SittingRoom << endl;
	//cout << "好基友正在访问：" << building->m_BedRoom << endl;
}

4.运算符重载

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

4.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

class Person
{
public:
	//1、成员函数重载+号
	/*Person operator+(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}*/
	int m_A;
	int m_B;
};

//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;

	return temp;
}

Person operator+(Person& p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;

	return temp;
}
 
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;

	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	//成员函数重载本质调用
	//Person p3 = p1.operator+(p2);
	
	// 全局函数重载本质调用
	//Person p3 = operator+(p1, p2);
	Person p3 = p1 + p2;
	//运算符重载也可以发生函数重载
	Person p4 = p1 + 10;

	cout << "p3.m_A = " << p3.m_A << endl;
	cout << "p3.m_B = " << p3.m_B << endl;
}
  • 总结1：对于内置数据类型的表达式的运算符是不可能改变的
  • 总结2：不要滥用运算符重载

4.2 左移运算符的重载

class Person
{
	friend ostream& operator<<(ostream& cout, Person p);

public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:
	//利用成员函数重载，返回左移运算符
	//一般不会利用成员函数来重载<<，因为无法实现cout在左侧
	int m_A;
	int m_B;
};

//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout, Person p)	//本质 operator<<(cout, p),简化cout << p
{
	cout << "m_A = " << p.m_A  << " m_B = " << p.m_B;
	return cout;
}

void test01()
{
	Person p(10, 10);

	cout << p << endl;
}
  • 总结：重载左移运算符配合友元可以实现输出自定义数据类型

4.3 递增运算符重载

作用： 通过重载递增运算符，实现自己的整形数据

class myInteger
{
	friend ostream& operator<<(ostream& cout, myInteger myint); 
public:
	myInteger()
	{
		m_Num = 0;
	}

	//重载前置++运算符，返回引用为了一直对一个数据进行递增操作
	myInteger& operator++()
	{
		m_Num++;
		return *this;
	}

	//重载后置++运算符，int代表站位参数，可以用于区分前置和后置递增
	myInteger operator++(int)
	{
		myInteger temp = *this;
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};

ostream& operator<<(ostream& cout, myInteger myint)
{
	cout << myint.m_Num;
	return cout;
}
  • 注： 前置递增返回引用，后置递增返回值

4.4 赋值运算符重载

C++编译器至少给一个类添加4个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性值进行拷贝
  4. 赋值运算符 operator=，对属性值进行拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

class Person
{
public:
	Person(int age)
	{
		m_Age = new int(age);
	}

	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//重载赋值运算符
	Person& operator=(Person &p)
	{
		//编译器提供浅拷贝
		//m_Age = p.m_Age; 

		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝

		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}

		m_Age = new int(*p.m_Age);

		//返回对象本身
		return *this;
	}

	int* m_Age;
};

void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1;

	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

4.5 关系运算符重载

作用： 重载关系运算符，可以让两个自定义类型对象进行对比操作

class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}

	bool operator==(Person p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		return false;
	}

	bool operator!=(Person p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		return true;
	}

	string m_Name;
	int m_Age;
};

4.6 函数调用运算符重载

  • 函数调用运算符 () 也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此成为仿函数
  • 仿函数没有固定写法，非常灵活
class MyPrint
{
public:

	void operator()(string text)
	{
		cout << text << endl;
	}
};

void test01()
{
	MyPrint myPrint;

	myPrint("Hello world");	//由于使用起来非常类似于函数调用，因此成为仿函数
    
    //匿名函数对象
    cout << MyAdd()(100, 100) << endl;
}

5 继承

5.1 继承的基本语法

class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册……（公共头部）" << endl;
	}
};

//语法：class 子类 : 继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类
class Java : public BasePage
{
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};

class CPP : public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.content();
	cout << "------------------" << endl;

	cout << "c++下载视频页面如下：" << endl;
	CPP cpp;
	cpp.header();
	cpp.content();
}

5.2 继承的方式

  • public:
    • 父类中的公共权限成员，到子类中依然是公共权限
    • 父类中的保护权限成员，到子类中依然是保护权限
    • 父类中的私有权限成员，子类访问不到
  • protected:
    • 父类中的公共权限成员和保护权限成员，到子类中变为保护权限
    • 父类中的私有权限成员，子类访问不到
  • private:
    • 父类中的公共权限成员和保护权限成员，到子类中变为私有权限
    • 父类中的私有权限成员，子类访问不到
      C++学习笔记_第1张图片

5.3 继承中的对象模型

  1. 父类中所有非静态成员属性都会被子类继承下去；
  2. 父类中私有成员属性，被编译器给隐藏了，因此访问不到，但确实是被继承下去了；
  3. 利用开发人员命令提示工具查看对象模型：跳转文件路径 cd
    c l / d 1 r e p o r t S i n g l e C l a s s L a y o u t 类名 " 文件名 " cl /d1 reportSingleClassLayout类名 "文件名" cl/d1reportSingleClassLayout类名"文件名"

5.4 继承同名成员处理方式

情景：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或者父类中同名的数据呢？

  • 访问子类同名成员，直接访问即可
  • 访问父类同名成员，需要加作用域
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base - func" << endl;
	}
	void func(int a)
	{
		cout << "Base - func(int a)" << endl;
	}

	int m_A;
};

class Son : public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "Son - func" << endl;
	}

	int m_A;
};

void test01()
{
	Son s;
	cout << "Son 下 m_A = " << s.m_A << endl;
	//如果通过子类对象访问到父类中同名成员，需要加作用域
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
}

void test02()
{
	Son s;
	s.func();	//直接调用，调用是子类中的同名成员

	s.Base::func();
	//如果子类中出现和父类同名成员函数，子类的同名成员函数，会隐藏掉父类中所有同名成员函数
	s.Base::func(100);
}

5.5 同名静态成员处理

  1. 静态成员和非静态成员出现同名，处理方式一致。

  2. 通过类名访问

    cout << "Son 下m_A = " << Son::m_A << endl;
//第一个双冒号代表通过类名方式访问 第二个双冒号代表访问父类作用域下
cout << "Base 下m_A = " << Son::Base::m_A << endl;

5.6 多继承语法

C++允许一个类继承多个类

语法： c l a s s 子类 : 继承方式父类 1 , 继承方式父类 2 … class 子类 : 继承方式 父类1 , 继承方式 父类2 … class子类:继承方式父类1,继承方式父类2…

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议使用多继承

class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}

	int m_A;
};

class Base2
{
public:
	Base2()
	{
		m_A = 200;
	}

	int m_A;
};

class Son : public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};

void test1()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	//当父类出现同名成员，需要加作用域区分
	cout << "m_A = " << s.Base1::m_A << endl;
	cout << "m_A = " << s.Base2::m_A << endl;
}

5.7 菱形继承

菱形继承概念：

  • 两个派生类继承同一个基类
  • 又有某个类同时继承两个派生类

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
  2. 草泥马继承自动物的数据继承了两份，但其实这份数据我们只需继承一份就可以
class Animal
{
public:
	int m_Age;
};

//利用虚继承 解决菱形继承的问题
//继承之前，加上关键字virtual，变为虚继承
//Animal类成为虚基类
class Sheep : virtual public Animal
{

};

class Tuo : virtual public Animal
{

};

class SheepTuo : public Sheep, public Tuo
{

};

void test1()
{
	SheepTuo st;
	//当出现菱形继承时，两个父类拥有相同数据，需要加以作用域区分
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
}

6 多态

6.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类：

  1. 静态多态：函数重载和运算符重载属于静态多态，复用函数名
  2. 动态多态：函数重写，派生类和虚函数实现运行时多态

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

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

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

//如果想执行让猫说话，这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

//动态多态满足条件
//1、有继承关系
//2、子类重写父类的虚函数

//动态多态使用
//父类的指针或者引用，指向子类对象
void doSpeak(Animal &animal)	//Animal &animal = cat;
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);
}

总结：

多态满足条件：

  • 有继承关系
  • 子类重写父类中的虚函数

多态使用条件：

  • 父类指针或引用指向子类对象

重写：子类函数返回值类型、函数名、参数列表与父类函数完全一致成为重写

6.2 纯虚函数和抽象类

在多态中，通常父类中虚函数的视线是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名（参数列表） = 0;

当类中有了纯虚函数，这个类也被称为抽象类

抽象类特点：

  • 无法实例化对象
  • 子类必须才重写抽象类中的纯虚函数，否则也属于抽象类
class Base
{
public:
	virtual void func() = 0;
};

class Son :public Base
{
public:
	virtual void func() {};
};

void test01()
{
	//Son s;	//子类必须要重写父类中的纯虚函数，否则无法实例化对象
	Base* base = new Son;
	base->func();
}

6.4 示例------->制作饮品

class AbstractDrinking
{
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 AbstractDrinking
{
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}

	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}

	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}

	virtual void PutSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}
};

//制作茶叶
class Tea :public AbstractDrinking
{
	virtual void Boil()
	{
		cout << "煮山泉水" << endl;
	}

	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}

	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}

	virtual void PutSomething()
	{
		cout << "加入枸杞" << endl;
	}
};

void doWork(AbstractDrinking* abs)
{
	abs->makeDrink();
	delete abs;	//释放在堆区new的数据
}

void test01()
{
	//制作咖啡
	doWork(new Coffee);
	cout << "-------------------------" << endl;
	AbstractDrinking* tea = new Tea;
	doWork(tea);
}

6.5 虚析构和纯虚析构

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

解决方式：将父类中的析构函数改为虚析构或纯虚析构

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

虚析构语法：virtual ~类名(){}

纯虚析构语法：virtual ~类名() = 0 类名::~类名(){}

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数的调用" << endl;
	}
	
	//利用虚析构可以解决父类指针释放子类对象不干净的问题
	/*virtual ~Animal()
	{
		cout << "Animal的析构函数的调用" << endl;
	}*/
	//纯虚析构，需要声明也需要实现
	virtual ~Animal() = 0;
	virtual void speak() = 0;
};

Animal::~Animal()
{
	cout << "Animal的纯析构函数的调用" << endl;
}

class Cat : public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat的构造函数的调用" << endl;
		m_Name = new string(name);
	}

	virtual void speak()
	{
		cout << *m_Name << "小猫在说话" << endl;
	}

	~Cat()
	{
		if (m_Name != NULL)
		{
			cout << "Cat的析构函数的调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}

	string *m_Name;
};

void test01()
{
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构的时候，不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏
	delete animal;
}

总结：

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

6.6 多态案例--------->电脑组装

class CPU
{
public:
	virtual void caculate() = 0;
};

class VideoCard
{
public:
	virtual void display() = 0;
};

class Memory
{
public:
	virtual void stroage() = 0;
};

class Computer
{
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	void work()
	{
		m_cpu->caculate();
		m_vc->display();
		m_mem->stroage();
	}

	~Computer()
	{
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}

		if (m_vc != NULL)
		{
			delete m_cpu;
			m_vc = NULL;
		}

		if (m_mem != NULL)
		{
			delete m_cpu;
			m_mem = NULL;
		}
	}

private:
	CPU* m_cpu;
	VideoCard* m_vc;
	Memory* m_mem;
};

class IntelCPU : public CPU
{
public:
	virtual void caculate()
	{
		cout << "Intel 的CPU开始计算了" << endl;
	}
};

class IntelVideoCard : public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel 的显卡开始显示了" << endl;
	}
};

class IntelMemory : public Memory
{
public:
	virtual void stroage()
	{
		cout << "Intel 的内存条开始存储了" << endl;
	}
};

class LenovoCPU : public CPU
{
public:
	virtual void caculate()
	{
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};

class LenovoVideoCard : public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};

class LenovoMemory : public Memory
{
public:
	virtual void stroage()
	{
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};

void test01()
{
	CPU* intelCPU = new IntelCPU;
	VideoCard* intelCard = new IntelVideoCard;
	Memory* intelMem = new IntelMemory;

	Computer* computer1 = new Computer(intelCPU, intelCard, intelMem);
	computer1->work();
	delete computer1;

	cout << "---------------------" << endl;
	cout << "第二台电脑开始工作" << endl;
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	computer2->work();
	delete computer2;
}

二、文件操作

C++中对文件操作需要包含头文件
操作文件的三大类：

  1. ofstream：写操作
  2. ifstream：读操作
  3. fstream：读写操作

1. 文本文件

1.1 写文件

写文件步骤如下：

  1. 包含头文件

    #include

  2. 创建流对象

    ofstream ofs;

  3. 打开文件

    ofs.open(“文件路径”, 打开方式);

  4. 写数据

    ofs << “写入的数据”;

  5. 关闭文件

    ofs.close();

文件打开方式：

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

注： 文件打开方式可以配合使用，利用 | 操作符

如： 用二进制方式写文件ios::binary | ios::out

void test01()
{
	ofstream ofs;

	ofs.open("test.txt", ios::out);
	ofs << "This is a test";
	ofs.close();
}

总结：

  • 读文件可以利用ofstream，或者fstream
  • 打开文件时候需要制定操作文件路径，以及打开方式
  • 利用<<可以向文件中写数据
  • 操作完毕，要关闭文件流

1.2 读文件

四种方式读取文本文件：

void test01()
{
	ifstream ifs;
	ifs.open("test.txt", ios::in);
	if (!ifs.is_open())
	{
		cout << "File is open fail!" << endl;
		return;
	}

	//第一种
	/*char buf[1024] = { 0 };
	while (ifs >> buf)
	{
		cout << buf << endl;
	}*/

	//第二种
	/*char buf[1024] = { 0 };
	while (ifs.getline(buf, sizeof(buf)))
	{
		cout << buf << endl;
	}*/

	//第三种
	/*string buf;
	while (getline(ifs, buf))
	{
		cout << buf << endl;
	}*/

	//第四种
	char c;
	while ((c = ifs.get()) != EOF)
	{
		cout << c ;
	}

	ifs.close();
}

2. 二进制文件

以二进制的方式对文件进行读写操作，打开方式要指定为ios::binary

2.1 写文件

二进制方式写文件主要利用流对象调用成员函数write

函数原型：ostream& write(const cher* buffer, int len)

参数解释：字符指针buffer 指向内存中一段存储空间。len 是读写的字节数

示例：

class Person
{
public:
	char m_Name[64];
	int m_Age;
};

void test01()
{
	ofstream ofs("Person.txt", ios::binary | ios::out);

	//ofs.open("Person.txt", ios::binary | ios::out);
	Person p = { "张三", 18 };
	ofs.write((const char*)&p, sizeof(Person));
	ofs.close();
}

2.2 读文件

二进制方式写文件主要利用流对象调用成员函数read

函数原型：ostream& read(const cher* buffer, int len);

参数解释：字符指针buffer 指向内存中一段存储空间。len 是读写的字节数

示例：

void test01()
{
	ifstream ifs;

	ifs.open("Person.txt", ios::binary | ios::in);
	if (!ifs.is_open())
	{
		cout << "The file is open fail!" << endl;
		return;
	}
	
	Person p;
	ifs.read((char*)&p, sizeof(Person));
	cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;

	ifs.close();
}

三、C++提高编程

1. 模版

  • C++提供两种模板机制：函数模板和类模板

1.1 函数模板

1.1.1 函数模板语法

函数模板的作用：

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

语法

template
函数声明或定义

template – 声明创建模板

typename – 表明其后面的符号是一种数据类型，可以用class代替

T – 通用的数据类型，名称可以替换，通常为大写字母

void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 1;
	int b = 2;
	//利用函数模板交换
	//两种方式使用函数模板

	//1. 自动类型推导
	//mySwap(a, b);

	//2. 显示指定类型
	mySwap(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

注意事项：

  • 自动类型推导，必须推导出一致的数据类型T，才可以使用
  • 模板必须要确定T的数据类型，才可以使用
template	
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 1;
	int b = 2;
	char c = 'c';

	//1、 自动类型推导
	//自动类型推导，必须推导出一致的数据类型T，才可以使用
	//mySwap(a, c);	//错误，推导不出一致的T类型

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

template
void func()
{
	cout << "func 的调用" << endl;
}

//2、模板必须要确定T的数据类型，才可以使用
void test02()
{
	//func();
	func();
}
1.1.2 普通函数与函数模板

  • 普通函数与函数模板的区别

    1. 普通函数调用时可发生自动类型转换（隐式类型转换）
    2. 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
    3. 如果利用显式指定类型的方式，可发生隐式类型转换

    注： 建议使用显式指定类型的方式，调用函数模板，因为可以自己确定通用类型T

  • 普通函数与函数模板调用规则

    1. 如果函数模板和普通函数都可以实现，优先调用普通函数

    2. 可以通过空模板参数列表来调用函数模板

      myPrint<>(a, b);

    3. 函数模板也可以发生重载

    4. 如果函数模板可以更好的匹配，优先调用函数模板

    注： 提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

1.1.3 模板的局限性
template
void f(T a, T b)
{
    a = b;
}

在上述的赋值操作，如果传入的a和b是一个数组，就无法实现了
C++为了解决这种问题，提供模板重载，可以为特定类型提供具体化的模板

class Person
{
public:
	Person(string Name, int Age)
	{
		this->m_Age = Age;
		this->m_Name = Name;
	}
	string m_Name;
	int m_Age;
};

template
bool myCompare(T& a, T& b)
{
	if (a == b)
		return true;
	else
		return false;
}

//利用具体化的Person的版本实现代码，具体化优先调用
template<>bool myCompare(Person& p1, Person& p2)
{
	if (p1.m_Age == p2.m_Age && p1.m_Name == p2.m_Name)
		return true;
	else
		return false;
}

总结：

  • 利用具体化的模板，可以解决自定义类型的通用化
  • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.2 类模板

1.2.1 类模板语法

类模板作用：

  • 建立一个通用类，类中的成员、数据类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template
类

示例：

template
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	void showPerson()
	{
		cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

void test01()
{
	Person p1("张三",999);
	p1.showPerson();
}
1.2.2 类模板和函数模板的区别

  1. 类模板没有自动类型推导的使用方式

  2. 类模板在模板参数列表中可以有默认参数

    template
……
void test02()
{
	Person p2("猪八戒", 999);
	p2.showPerson();
}

类模板中成员函数创建时机

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
1.2.3 类模板对象做函数参数

向函数传入类模板类型的参数，一共有三种传入方式：

  1. 制定传入类型 —直接显示对象的数据类型
  2. 参数模板化 —将对象中的参数变为模板进行传递
  3. 整个类模板化 —将这个对象类型模板化进行传递
//类模板对象做函数参数
template
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	void showPerson()
	{
		cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
	}
	T1 m_Name;
	T2 m_Age;
};

//1、指定传入类型
void printPerson(Person& p)
{
	p.showPerson();
}

void test01()
{
	Person p1("孙悟空", 999);
	p1.showPerson();
}

//2、参数模板化
template
void printPerson2(Person& p)
{
	p.showPerson();
	cout << "T1的类型为：" << typeid(T1).name() << endl;
}

void test02()
{
	Person p2("猪八戒", 1000);
	printPerson2(p2);
}

//3、整个类模板化
template
void printPerson3(T& p)
{
	p.showPerson();
	cout << "T的类型为：" << typeid(T).name() << endl;
}

void test03()
{
	Person p3("唐僧", 30);
	printPerson3(p3);
}
1.2.4 类模板与继承

当类模板碰到继承时，需要注意以下几点：

  1. 当子类继承的父类是一个模板时，子类在声明的时候，要指定出父类中T的类型

    template
class Base
{
	T m;
};

//class Son : public Base	//错误，必须要知道父类中T的类型，才能继承给子类
class Son : public Base
{

};

  2. 如果不指定，编译器无法给子类分配内存

  3. 如果想灵活指定出父类中T的类型，子类也需变为类模板

    template
class Base
{
	T m;
};

template
class Son2 :public Base //指定Base中的模板类型为T2
{
	T1 obj;
};

总结： 如果父类是模板，子类需要制定出父类中T的数据类型

1.2.5 类模板成员的类外实现
template
class Person
{
public:
	Person(T1 name, T2 age);
	void showPerson();
    
	T1 m_Name;
	T2 m_Age;
};

template
Person::Person(T1 name, T2 age)
{
		this->m_Age = age;
		this->m_Name = name;
}

//成员函数的类外实现
template
void Person::showPerson()
{
		cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}
1.2.6 类模板分文件编写

问题：

  • 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

  • 解决方式1：直接包含.cpp源文件

    #include "Person.cpp" //直接包含.cpp

void test01()
{
	Personp("Jerry", 18);
	p.showPerson();
}

  • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，.hpp是约定的名称，并不是强制

示例：

person.hpp中的代码：

#pragma once
#include 
#include 
using namespace std;


//类模板对象做函数参数
template
class Person
{
public:
	Person(T1 name, T2 age);
	void showPerson();

	T1 m_Name;
	T2 m_Age;
};

template
Person::Person(T1 name, T2 age)
{
	this->m_Age = age;
	this->m_Name = name;
}

//成员函数的类外实现
template
void Person::showPerson()
{
	cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}

mian.cpp 中的代码

#include "Person.hpp"

void test01()
{
	Personp("Jerry", 18);
	p.showPerson();
}
1.2.7 类模板与友元
  1. 全局函数类内实现—》直接在类内声明友元即可
  2. 全局函数类外实现—》需提前让编译器知道全局函数的存在

示例：

//提前让编译器知道Person类的存在
template
class Person;

//全局函数在类外实现
template
void showPerson2(Person p)
{
	cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
}

template
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	//全局函数类内实现，直接在类内声明友元即可
	/*friend void showPerson(Person p)
	{
		cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
	}*/

	//全局函数，类外实现
	//加空模板的参数列表
	//如果全局函数类外实现，需提前让编译器知道全局函数的存在
	friend void showPerson2<>(Person p);
	
private:
	T1 m_Name;
	T2 m_Age;
};

void test01()
{
	Personp("Tom", 20);
	showPerson2(p);
}
1.2.8 类模板案例

实现一个通用的数组类，要求如下：

  • 可以对内置数据类型以及自定义数据类型的数据进行存储
  • 将数组中的数据存储到堆区
  • 构造函数中可以传入数组的容量
  • 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
  • 提供尾插法和尾删法对数组中的数据进行增加和删除
  • 可以通过下标的方式访问数组中的元素
  • 可以获取数组中当前元素个数和数组的容量

2. STL初识

2.1 STL 基本概念

  • STL 从广义上分为：容器（container），算法（algorithm），迭代器（iterator）；
  • 容器和算法之间通过迭代器进行无缝连接；
  • STL 几乎所有代码都采用了模板类或者模板函数。

2.2 STL 六大组件

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

  1. 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据；
  2. 算法：各种常用算法，如sort、find、copy、for_each等；
  3. 迭代器：扮演了容器与算法之间的胶合剂；
  4. 仿函数：行为类似函数，可作为算法的某种策略；
  5. 适配器：一种用来修饰容器或者仿函数或者迭代器接口的东西；
  6. 空间适配器：负责空间的配置与管理。

2.3 容器、算法、迭代器

容器：

STL 容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组、链表、树、栈、队列、集合、映射表等

这些容器分为** 序列式容器和关联式容器**两种：

序列式容器： 强调值的排序，序列式容器中的每个元素均有固定的位置。

关联式容器： 二叉树结构，各元素之间没有严格的物理上的顺序关系

算法： 问题之解法也

有限的步骤，解决逻辑或者数学上的问题，这一门学科我们叫做算法(Algorithms)

算法分为：质变算法和非质变算法。

质变算法：指运算过程中会更改区间内的元素的内容，例如拷贝、替换、删除等

非质变算法：指运算过程中不会更改区间内的元素的内容，如查找、便利、计数等

迭代器： 容器和算法之间粘合剂

提供一种方法，使之能够依序号寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

每个容器都有自己专属的迭代器

迭代器差不多类似于指针，初学者可以把其当作指针来用

迭代器种类：

种类 功能 支持运算
输入迭代器 对数据的只读访问 只读，支持++、==、!=
输出迭代器 对数据的只写访问 只写，支持++
前向迭代器 读写操作，并能向前推进迭代器 读写，支持++、==、!=
双向迭代器 读写操作，并能向前向后操作 读写，支持++、–
随机访问迭代器 读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器 读写，支持++、==、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器和随机访问迭代器

2.4 容器嵌套容器

示例：

void test01()
{
	vector> v;
	vectorv1;
	vectorv2;
	vectorv3;
	vectorv4;

	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}

	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);

	for (vector>::iterator it = v.begin(); it != v.end(); it++)
	{
		for (vector::iterator ix = (*it).begin(); ix != (*it).end(); ix++)
		{
			cout << *ix << " ";
		}
		cout << endl;
	}
}

3. STL 常用容器

3.1 string 容器

本质：

  • string本质上是一个类

string和char * 区别：

  • char * 是一个指针
  • string 是一个类，类内部封装了char *，管理这个字符串，是一个char * 型的容器

特点： string 管理char * 所分配的内存，不用担心赋值越界和取值越界等，由类内部进行负责

3.1.1 string 构造函数

构造函数原型：

  • string(): 创建一个空的字符串，例如string str;

    string(const char* s) 使用字符串s 初始化

  • string(const string &str) 使用一个string 对象初始化另一个string 对象

  • string(int n, char c) //使用n 个字符c 串初始化

3.1.2 string 赋值操作

赋值的函数原型：

  • string& operator=(const char* s):char* 类型字符串，赋值给当前字符串
  • string& operator=(const string &s):把字符串s 赋给当前字符串
  • string& operator=(char c):把字符c 赋给当前字符串
  • string assign(const char *s):把字符串s 赋给当前字符串
  • string assign(const char *s, int n):把字符串s 的前n个字符赋给当前字符串
  • string assign(const string &s):把字符串s 赋给当前字符串
  • string assign(int n, char c):用n 个字符c 赋给当前字符串
void test01()
{
	string str1;
	str1 = "Hello World";
	string str2;
	str2 = str1;

	string str4;
	str4.assign("hello C++");
	

	string str5;
	str5.assign("hello C++", 5);
	
	string str6;
	str6.assign(str5);

	string str7;
	str7.assign(10, 'w');
}
3.1.3 字符串拼接
string str1 = "我";
	str1 += "爱玩游戏";
	
	str1 += ':';
	string str2 = "LOL DNF";
	str1 += str2;

	string str3 = "I";
	str3.append(" love ");	//把参数内的字符串拼接到str3末尾
	str3.append("game aaaa", 4);把参数内的字符串的前4个字符拼接到str3末尾
	//str3.append(str2);//str2拼接到str3当末尾
	str3.append(str2,4,3);//从字符串str2的第四个字符开始，截取3个字符拼接到str3末尾
3.1.4 string 查找和替换

函数原型：

  • int find(const string& str, int pos = 0) const; //查找str第一次出现位置，从pos开始查找
  • int find(const char* s，int pos = 0) const; //查找s第一次出现位置,从pos开始查找
  • int find(const char* S, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
  • int find(const char c，int pos = 0) const; //查找字符c第一次出现位置
  • int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
  • int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置，从pos开始查找
  • int rfind(const char* s，int pos, int n) const; //从pos查找s的前n个字符最后一次位置
  • int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
  • string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
  • string& replace(int pos， int n,const char* s); //替换从pos开始的n个字符为字符串s
//从1号位置起3个字符串替换为 1111
str1.replace(1, 3, "1111");
3.1.5 string 字符串比较

  • 字符串是按照字符串的ASCII 码进行比较

    =返回 0

    >返回 1

    <返回 -1

函数原型：

  • int compare(const string &s)const; 与字符串s 比较
  • int compare(const char *s)const; 与字符串s 比较
3.1.6 string 字符存取
  • char& operator[](int n);;通过[] 方式获取字符
  • char& at(int n); 通过at 方法获取字符
string str1 = "abcdefg";
	
	for (int i = 0; i < str1.size(); i++)
	{
		cout << str1[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str1.size(); i++)
	{
		cout << str1.at(i) << " ";
	}
	cout << endl;
3.1.7 string 插入和删除

函数原型：

  • string& insert(int pos, const char* s); //插入字符串
  • string& insert(int pos, const string& str); //插入字符串
  • string& insert(int pos, int n, char c); //在指定位置插入n个字符C
  • string& erase(int pos, int n = npos); //删除从Pos开始的n个字符
3.1.8 string 获取子串

函数原型：

  • string substr(int pos = 0, int n = npos) const; 返回由pos 开始的n 个字符组成的字符串

3.2 vector 容器

3.2.1 vector 基本概念

功能：与数组类似，也被称为单端数组，与普通数组的区别在于vector 可以动态扩展

动态扩展： 并不是在原空间之后接续新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

  • vector 容器的迭代器是支持随机访问的迭代器
3.2.2 vector 构造函数

函数原型：

  • vector v; //采用模板实现类实现，默认构造函数
  • vector(v.begin(), v.end()); //将[v.begin(), v.end())区间的元素拷贝给本身
  • vector(n, elem); //构造函数将n个elem 拷贝给本身
  • vector(const vector &vec); //拷贝构造函数
vectorv1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	//通过区间方式进行构造
	vectorv2(v1.begin(), v1.end());

	//n个elem方式构造
	vectorv3(10, 100);

	//拷贝构造
	vectorv4(v3);
3.2.3 vector 赋值操作

函数原型：

  • vector& operator=(const vector &vec); //重载等号操作符
  • assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
  • assign(n,elem); //将n个elem拷贝赋值给本身
vectorv1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	vectorv2;
	v2 = v1;

	vectorv3;
	v3.assign(v1.begin(), v1.end());
	
	vectorv4;
	v4.assign(10, 100);
3.2.4 vector 容量和大小

函数原型：

  • empty(); //判断容器是否为空
  • capacity(); //容器的容量
  • size(); //返回容器中元素的个数
  • resize(int num); //重新指定容器的长度为mun，若容器变长，则以默认值填充新位置
    //如果容器变短，则末尾超出容器长度的元素被删除
  • resize(int num, elem); //重新指定容器的长度为mun，若容器变长，则以elem填充新位置
    //如果容器变短，则末尾超出容器长度的元素被删除 
vectorv1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	if (v1.empty())
		cout << "v1为空" << endl;
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量为：" << v1.capacity() << endl;
		cout << "v1的大小为：" << v1.size() << endl;
	}

	//v1.resize(15);
	v1.resize(15, 1);
3.2.5 vector 插入和删除

函数原型：

  • push_ back(ele); //尾部插入元素ele
  • pop_ back(); //删除最后一个元素
  • insert(const_ iterator pos, ele); //迭代器指向位置pos插入元素ele
  • insert(const_ iterator pos, int count,ele); //迭代器指向位置pos插入count个元素ele
  • erase(const_ iterator pos); //删除迭代器指向的元素
  • erase(const_ iterator start, const_ iterator end); //删除迭代器从start到end之间的元素
  • clear(); //删除容器中所有元素
vectorv1;

	for (int i = 0; i < 5; i++)
	{
		v1.push_back(i * 10 + 10);
	}
	v1.pop_back();
	
	v1.insert(v1.begin(), 100);	//开头位置插入100

	v1.insert(v1.begin(), 2, 1000);	//在头部插入两个1000

	v1.erase(v1.begin());	//删除头部的第一个元素

	v1.erase(v1.begin(), v1.end());
3.2.6 vector 数据存取

函数原型：

  • at(int idx); //返回索引 idx所指的数据
  • operator[]; //返回索引 idx所指的数据
  • front(); //返回容器中第一个数据元素
  • back(); //返回容器中最后一个数据元素
3.2.7 vector 互换容器

函数原型：

  • swap(vec); //将vec 与本身的元素互换
v1.swap(v2);

//使用swap收缩内存
	//vector(v)	匿名对象，使用拷贝构造函数创建了一个新的对象
						//会按照v的元素个数初始化这个匿名对象，故容量和元素个数都一致
	vector(v).swap(v);
  • swap 可以使两个容器互换，可以达到实用的收缩内存效果
3.2.8 vector 预留空间

功能描述：

  • 减少vector 在动态扩展内存时的扩展次数

函数原型：

  • reserve(int len); //容器预留len 个元素长度，预留位置不初始化，元素不可访问
vectorv1;
	v1.reserve(100000);
	int num = 0;
	int* p = nullptr;

	for (int i = 0; i < 100000; i++)
	{
		v1.push_back(i);
		if (p != &v1[0])
		{
			p = &v1[0];
			num++;
		}
	}
	cout << "num = " << num << endl;

3.3 deque 容器

3.3.1 deque 容器基本概念

功能： 双端数组，可以对头端进行插入删除操作

deque 与 vector 的区别：

  • vector 对于头部的插入删除效率较低，数据量越大，效率越低
  • deque 相对于而言，对头部的插入删除速度会比vector快
  • vector 访问元素时的速度回比deque 快，这和两者的内部实现有关
    • deque 提供了头部和尾部的插入和删除的接口（pushu_font()、push_back()）
    • deque 内部工作原理：
      • deque 内部有个**中控器，**维护每段缓冲区的内容，缓冲区内存放真实数据
      • 中控器维护的是每个缓冲区的地址，使得使用deque 时像一片连续的内存空间
3.3.2 deque 构造函数

函数原型：

  • dequedeqT //默认构造形式
  • deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身
  • deque(n, elem); //构造函数将n个elem拷贝给本身
  • deque(const deque &deq); //拷贝构造函数

const_iterator 只读迭代器

void printDeque(const deque& de)
{
	for (deque::const_iterator it = de.begin(); it != de.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	dequed1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	dequed2(d1.begin(), d1.end());
	printDeque(d2);

	dequed3(10, 100);
	printDeque(d3);

	dequed4(d3);
}
3.3.3 deque 赋值操作

函数原型：

  • deque& operator=(const deque &deq); //重载等号操作符
  • assign(beg, end); //将[beg, end) 区间中的数据拷贝赋值给本身
  • asign(n, elem); //将n个elem拷贝赋值给本身
3.3.4 deque大小操作

函数原型：

  • deque.empty(); //判断容器是否为空
  • deque.size(); //返回容器中元素的个数
  • deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
  • deque.resize(num,elem); //重新指定容器的长度为num，若容器变长，则以elem填充新位置
3.3.5 deque 插入和删除

函数原型：

两端插入操作：

  • push_back(elem); //在容器尾部添加一个数据
  • push_front(elem); //在容器头部插入一个数据
  • pop_back(); //删除容器最后一个数据
  • pop_front(); //删除容器第一个数据

指定位置操作：

  • insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
  • insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值
  • insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值
  • clear(); //清空容器的所有数据
  • erase(beg,end); //删除[beg,end)区间的数据，返回下一数据的位置
  • erase(pos); //删除pos位置的数据，返回下一个数据的位置
void test01()
{
	dequed1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	
	dequed2;
	d2.push_back(10);
	d2.push_back(20);
	d2.push_back(30);

	//在d1头部插入d2
	d1.insert(d1.begin(), d2.begin(), d2.end());
	
	//删除d1第2个元素
	deque::iterator it = d1.begin();
	it++;
	d1.erase(it);

	//清空d1
	d1.erase(d1.begin(), d1.end());
}
3.3.6 deque 数据存取

函数原型：

  • at(int idx); //返回索引 idx所指的数据
  • operator[idx]; //返回索引idx所指的数据
  • front(); //返回容器中第一个数据元素
  • back(); //返回容器中最后一个数据元素

3.4 stack 容器

  • stack 容器是一种后进先出的数据结构，它只有一个出口
  • 栈中只有顶端元素才可以被外界使用，因此栈不允许有遍历行为

stack 常用接口

构造函数：

  • stack stk; //stack采用模板类实现，stack对象的默认构造形式
  • stack(const stack &stk); //拷贝构造函数

赋值操作：

  • stack operator=(const stack &stk); //重载等号赋值操作

数据存取：

  • push(elem); //向栈顶添加元素
  • pop(elem); //从栈顶移除一个元素
  • top(); //返回栈顶元素

大小操作

  • size(); //返回栈的大小
  • empty(); //判断栈是否为空

3.5 queue 容器

Queue 是一种先进先出的数据结构，它有两个出口

  • 队列允许从一端新增元素，从另一端移除元素
  • 队列只有队头队尾可以被外界使用，因此队列不允许遍历行为

构造函数：

  • queue que; //queue采用模板类实现，queue对象的默认构造形式
  • queue(const queue &que); //拷贝构造函数

数据存取：

  • push(elem); //向队尾添加元素
  • pop(elem); //从队头移除一个元素
  • back(); //返回最后一个元素
  • front(); //返回第一个元素

大小操作

  • size(); //返回队列的大小
  • empty(); //判断队列是否为空

3.6 list 容器（链表）

概念： 链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的；链表由一系列结点组成

优点： 可以对任意位置进行快速插入或删除元素；采用动态分配内存，不会造成内存浪费和溢出

缺点： 容器遍历速度没有数组快，占用空间比数组大

注： STL 中的链表是一个双向循环链表

3.6.1 list 构造函数

函数原型：

  • list lst; //list采用类模板实现，对象的默认构造形式
  • list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身
  • list(n,elem); //构造函数将n个elem拷贝给本身
  • list(const list &lst); //拷贝构造函数
3.6.2 list 赋值和交换

函数原型：

  • list& operator=(const list &lst); //重载等号操作符
  • assign(beg, end); //将[beg, end) 区间中的数据拷贝赋值给本身
  • asign(n, elem); //将n个elem拷贝赋值给本身
  • swap(lst); //将lst 与本身的元素互换
void test01()
{
    list L1;

    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    list L2;
    L2.assign(10, 100);
    L1.swap(L2);
}
3.6.3 list 大小操作

函数原型：

  • empty(); //判断容器是否为空
  • size(); //返回容器中元素的个数
  • resize(int num); //重新指定容器的长度为mun，若容器变长，则以默认值填充新位置
    //如果容器变短，则末尾超出容器长度的元素被删除
  • resize(int num, elem); //重新指定容器的长度为mun，若容器变长，则以elem填充新位置
    //如果容器变短，则末尾超出容器长度的元素被删除
3.6.4 list 插入和删除

函数原型：

  • push_back(elem); //在容器尾部添加一个元素
  • push_front(elem); //在容器头部插入一个元素
  • pop_back(); //删除容器最后一个元素
  • pop_front(); //删除容器第一个元素
  • insert(pos, elem); //迭代器指向位置pos插入元素elem
  • insert(pos, n,ele); //迭代器指向位置pos插入n个元素ele
  • insert(pos,beg,end); //在pos位置插入[beg, end)区间的数据，无返回值
  • erase(pos); //删除pos位置的数据，返回下一个数据的位置
  • erase(beg, end); //删除迭代器[beg, end)的元素
  • clear(); //删除容器中所有元素
  • remove(elem); //删除容器中所有与elem值匹配的元素

数据存取：

  • front(); //返回第一个元素
  • back(); //返回最后一个元素
3.6.5 list 排序和反转

注： 所有不支持随机访问迭代器的容器，不可以用标准算法。不支持随机访问迭代器的容器，内部会提供对应一些算法

函数原型：

  • sort();
  • reverse();
bool myCompare(int v1, int v2)
{
    return v1 > v2;
}

void test01()
{
    list L1;

    L1.push_back(3);
    L1.push_back(2);
    L1.push_back(6);
    L1.push_back(1);

    L1.sort();
    L1.reverse();
    L1.sort(myCompare);   //降序，myCompare为自定义规则
}

3.7 set/ multiset容器

3.7.1 set 基本概念
  • 所有元素都会在插入时自动被排序

本质：

  • set/ multiset属于关联式容器，底层结构是用二叉树实现

set和 multiset区别：

  • set不允许容器中有重复的元素
  • multiset 允许容器中有重复的元素
3.7.2 set构造和赋值

构造：

  • set st; //默认构造函数
  • set(const set &st); //拷贝构造函数

赋值：

  • set& operator=(const set &st); //重载等号操作符
	sets1;

    s1.insert(10);
    s1.insert(30);
    s1.insert(20);
    s1.insert(40);
    
    //拷贝构造
    sets2(s1);

    sets3;
    s3 = s2;
3.7.3 set 容器常用接口

大小和交换：

  • size(); //返回容器中元素的数目
  • empty(); //判断容器是否为空
  • swap(st); //交换两个集合容器

插入和删除：

  • insert(elem); //在容器中插入元素
  • clear(); //清除所有元素
  • erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器
  • erase(beg, end); //删除区间[beg, end)的所有元素，返回下一个元素的迭代器
  • erase(elem); //删除容器中值为elem的元素
sets1;
    
s1.erase(s1.begin());
s1.erase(30);
s1.erase(s1.begin(), s1.end());

查找和统计

  • find(key); //查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回set.end();
  • count(key); //统计key的元素个数
3.7.4 pair 对组的创建

功能： 成对出现的数据，利用对租可以返回两个数据

创建方式：

  • pair p (value1, value2);
  • pair p = make_pair(value1, value2);
3.7.5 set 容器排序

  1. 内置类型制定排序规则

    利用仿函数，可以改变排序规则

    class MyCompare
{
public:
    bool operator()(int v1, int v2) const
    {
        return v1 > v2; // 修改为 v1 > v2 表示降序排序
    }
};

void test01()
{
    set s1;  // 降序排序,默认为升序排序

    s1.insert(10);
    s1.insert(30);
    s1.insert(20);
    s1.insert(40);

    for (set::const_iterator it = s1.begin(); it != s1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

  2. 自定义数据类型指定排序规则

    class Person
{
public:
    Person(string name, int age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }
    int m_Age;
    string m_Name;
};

class comparePerson
{
public:
    bool operator()(const Person& p1, const Person& p2)
    {
        return p1.m_Age > p2.m_Age;
    }
};

void test01()
{
    //自定义数据类型，指定排序规则
    set s;

    Person p1("刘备", 35);
    Person p2("关羽", 33);
    Person p3("张飞", 31);
    Person p4("赵云", 30);

    s.insert(p1);
    s.insert(p2);
    s.insert(p3);
    s.insert(p4);


}

3.8 map 容器

3.8.1 map 容器基本概念

简介：

  • map 中所有元素都是pair
  • pair 中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
  • 所有元素都会根据元素的键值自动排序

本质：

  • map/multimap 属于关联式容器，底层结构是用二叉树实现

优点：

  • 可以根据key值快速找到value值

map和multimap 的区别：

  • map不允许容器中有重复key值元素
  • multimap允许容器中有重复key值元素

map赋值和构造

mapm;
m.insert(pair(1,10));
m.insert(make_pair(2,20));
3.8.2 map 常用接口

map 大小和交换

  • size(); //返回容器中元素个数
  • empty(); //判断容器是否为空
  • swap(); //交换两个集合容器

插入和删除：

  • insert(elem); //在容器中插入元素
  • clear(); //清除所有元素
  • erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器
  • erase(beg, end); //删除区间[beg, end)的所有元素，返回下一个元素的迭代器
  • erase(key); //删除容器中值为key的元素

查找和统计

  • find(key); //查找key是否存在，若存在，返回该键元素的迭代器；若不存在，返回set.end();
  • count(key); //统计key的元素个数
3.8.3 map 容器排序
  • map 容器默认排序规则为：按照key值进行从小到大排序
  • 也可以像set 容器那样，利用仿函数，改变排序规则
class MyCompare
{
public:
    bool operator()(int v1, int v2) const
    {
        return v1 > v2; // 修改为 v1 > v2 表示降序排序
    }
};

4. STL 函数对象

4.1 函数对象

概念:

  • 重载函数调用操作符的类，其对象称为函数对象
  • 函数对象使用重载的() 时，行为类似函数调用，也叫仿函数

本质：

函数对象（仿函数）是一个类，不是一个函数

4.1.1 函数对象的使用

  • 函数对象在使用时，可以像普通函数那样使用，可以有参数，可以有返回值

    class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test01()
{
	MyAdd myAdd;
	myAdd(10, 10);	//返回结果为 10 + 10 = 20
	cout << myAdd(10, 10) << endl;

}

  • 函数对象超出普通函数的概念，函数对象可以有自己的状态

    class MyPrint
{
public:
	MyPrint()
	{
		this->count = 0;
	}
	void operator()(string test)
	{
		cout << test << endl;
		this->count++;
	}

	int count;	//内部自己状态
};

void test02()
{
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");

	cout << myPrint.count << endl; //2次
}

  • 函数对象可以作为参数传递

    void doPrint(MyPrint& mp, string test)
{
	mp(test);
}

void test03()
{
	MyPrint myPrint;
	doPrint(myPrint, "Hello C++");
}

4.2 谓词

概念：

  • 返回bool 类型的仿函数称为谓词
  • 如果operator() 接受一个参数，那么叫做一元谓词
  • 如果operator() 接受两个参数，那么叫做二元谓词
4.2.1 一元谓词例子
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vector v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	//查找容器中有没有大于5的数字
	//GreaterFive() 匿名函数对象
	vector::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "找到了大于5的数字为："<< *it << endl;
	}
}
4.2.1 二元谓词例子
class MyCompare
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};

void test01()
{
	vector v;
	v.push_back(2);
	v.push_back(1);
	v.push_back(5);
	v.push_back(3);
	v.push_back(4);

	//使用函数对象，改变算法策略，变为排序规则为从大到小
	sort(v.begin(), v.end(), MyCompare());
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

4.3 内建仿函数对象

概念： STL 内建了一些函数对象

分类：

  • 算术仿函数
  • 关系仿函数
  • 逻辑仿函数

用法：

  • 这些仿函数所产生的对象，用法和一般仿函数相同
  • 使用内建仿函数对象，需要引入头文件#include
4.3.1 算术仿函数

功能描述：

  • 实现四则运算
  • 其中negate是一元运算，其他都是二元运算

仿函数原型：

  • template T plus //加法仿函数
  • template T minus //减法仿函数
  • template T multiplies //乘法仿函数
  • template T divides //除法仿函数
  • template T modulus //取模仿函数
  • template T negate //取反仿函数

示例：

void test01()
{
	//取反仿函数
	negaten;
	cout << n(50) << endl;

	//plus 加法仿函数
	plusp;
	cout << p(10, 20) << endl;
}
4.3.2 关系仿函数
  • template bool equal_to //等于
  • template bool no_equal_to //不等于
  • template bool grater //大于
  • template bool grater_equal //大于等于
  • template bool less //小于
  • template bool less_equal //小于等于
void test01()
{
	vectorv;
	v.push_back(10);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);
	v.push_back(20);

	//降序
	sort(v.begin(), v.end(), greater());
}
4.3.3 逻辑仿函数
  • template bool logical_and //逻辑与
  • template bool logical_or //逻辑或
  • template bool logical_not //逻辑非
void test01()
{
	vectorv;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);

	vectorv2;
	//利用逻辑非，将容器v搬运到v2中，并执行取反操作
	v2.resize(v.size());
	transform(v.begin(), v.end(), v2.begin(), logical_not());
}

5 STL 常用算法

  • 算法主要是由头文件functional algorithm numeric组成
  • functional：定义了一些模板类，用以生命函数对象
  • algorithm：是所有STL 头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制和修改等
  • numeric：只包括几个在序列上面进行简单数学运算的模板函数

5.1 常用遍历算法

5.1.1 for_each

**作用：**遍历容器

函数原型：

  • for_each(iterator beg, iterator end, _func);

    //beg 开始迭代器

    //end 结束迭代器

    //_func 函数或者函数对象

void print01(int val)
{
	cout << val << " ";
}

//仿函数
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	for_each(v.begin(), v.end(), print01);
	cout << endl;

	for_each(v.begin(), v.end(), print02());
	cout << endl;
}
5.1.2 transform

作用： 搬运容器到另一个容器中

函数原型：transform(iterator beg1, iterator end1,iterator beg2,_func)

​ //beg1 源容器开始迭代器

​ //end1 源容器结束迭代器

​ //beg2 目标容器开始迭代器

​ //_func 函数或者函数对象

class Transform
{
public:
	int operator()(int v)
	{
		return v + 100;
	}
};

void print01(int val)
{
	cout << val << " ";
}

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vectorvTarget;
	vTarget.resize(v.size());

	transform(v.begin(), v.end(), vTarget.begin(), Transform());
	for_each(vTarget.begin(), vTarget.end(), print01);
	cout << endl;
}

5.2 常用查找算法

  • find //查找元素
  • find_if //按条件查找元素
  • adjacent_find //查找相邻重复元素
  • binary_search //二分查找
  • count //统计元素个数
  • count_if //按条件统计元素个数
5.2.1 find

功能： 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：find(iterator beg, iterator end, value);

//beg 开始迭代器

//end 结束迭代器

//value 查找的元素

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector::iterator it = find(v.begin(), v.end(), 5);
	if (it != v.end())
		cout << "找到：" << *it << endl;
	else
		cout << "没有找到！" << endl;
}

/*自定义数据类型*/
class Person
{
public:
	Person(int age, string name)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	//重载==，让底层find知道如何对比Person数据类型
	bool operator==(const Person& p)
	{
		if (this->m_Age == p.m_Age && this->m_Name == p.m_Name)
			return true;
		else
			return false;
	}

	int m_Age;
	string m_Name;
};

void test02()
{
	vectorv;
	Person p1(10, "aaa");
	Person p2(20, "bbb");
	Person p3(30, "ccc");
	Person p4(40, "ddd");

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	Person pp(20, "bbb");
	vector::iterator it = find(v.begin(), v.end(), pp);
	if (it != v.end())
		cout << "找到元素 姓名：" << it->m_Name << " 年龄：" << it->m_Age << endl;
	else
		cout << "没有找到！" << endl;
}
5.2.2 find_if

功能： 按条件查找元素

函数原型：find_if(iterator beg, iterator end, _Pred);

//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

//beg 开始迭代器

//end 结束迭代器

//_Pred 函数或者谓词（返回bool 类型的仿函数）

示例：

class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it != v.end())
		cout << "找到：" << *it << endl;
	else
		cout << "没有找到！" << endl;
}
5.2.3 adjacent_find

功能： 查找相邻重复元素

函数原型：find(iterator beg, iterator end);

//查找相邻重复元素，返回相邻重复元素第一个位置的迭代器

//beg 开始迭代器

//end 结束迭代器

void test01()
{
	vectorv;
	v.push_back(1);
	v.push_back(2);
	v.push_back(2);
	v.push_back(3);

	vector::iterator it = adjacent_find(v.begin(), v.end());
	if (it != v.end())
		cout << "找到相邻重复元素：" << *it << endl;
	else
		cout << "没有找到！" << endl;
}
5.2.4 binary_search

功能： 查找指定元素是否存在

函数原型：bool binary_search(iterator beg, iterator end, value);

//查找指定的元素，查到返回true，否则返回false

//在无序序列中不可用

//beg 开始迭代器

//end 结束迭代器

//value 查找的元素

vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	bool result = binary_search(v.begin(), v.end(), 4);

	if (result)
		cout << "找到！" << endl;
	else
		cout << "未找到！！" << endl;
5.2.5 count

功能： 统计元素个数

函数原型：count(iterator beg, iterator end, value);

//beg 开始迭代器

//end 结束迭代器

//value 统计的元素

class Person
{
public:
	Person(int age, string name)
	{
		this->m_Age = age;
		this->m_Name = name;
	}
	bool operator==(const Person& p)
	{
		if (this->m_Age == p.m_Age)
			return true;
		else
			return false;
	}
	string m_Name;
	int m_Age;
};

void test02()
{
	vectorv;
	Person p1(10, "aaa");
	Person p2(20, "bbb");
	Person p3(20, "ccc");
	Person p4(40, "ddd");

	Person p(20, "eee");

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	int num = count(v.begin(), v.end(), p);
	cout << "和p年龄相同的人有：" << num << "个！" << endl;
}
5.2.6 count_if

功能： 按条件统计元素个数

函数原型：count_if(iterator beg, iterator end, _Pred);

//beg 开始迭代器

//end 结束迭代器

//_Pred 谓词

class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	int num = count_if(v.begin(), v.end(), GreaterFive());
	cout << num << endl;
}

5.3 常用排序算法

  • sort //对容器内元素进行排序
  • random_shuffle //洗牌，指定范围内的元素随机调整次序
  • merge //容器元素合并，并存储到另一容器中
  • reverse //反转指定范围的元素
5.3.1 sort

功能： 对容器内元素进行排序

函数原型：sort(iterator beg, iterator end, _Pred);

//beg 开始迭代器

//end 结束迭代器

//_Pred 谓词

void Myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vectorv;
	v.push_back(2);
	v.push_back(4);
	v.push_back(1);
	v.push_back(3);

	sort(v.begin(), v.end(), greater());

	for_each(v.begin(), v.end(), Myprint);
	cout << endl;
}
5.3.2 random_shuffle

功能： 洗牌，指定范围内的元素随机调整次序

函数原型：random_shuffle(iterator beg, iterator end)

//beg 开始迭代器

//end 结束迭代器

void test01()
{
	srand((unsigned int)time(NULL));
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	random_shuffle(v.begin(), v.end());

	for_each(v.begin(), v.end(), Myprint);
	cout << endl;
}
5.3.3 merge

功能： 两个容器元素合并，并存储到另一个容器中

函数原型：

  • merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

​ //两个容器必须是有序的

​ //beg1 容器1开始迭代器

​ //end1 容器1结束迭代器

​ //beg2 容器2开始迭代器

​ //end 容器2结束迭代器

​ //dest 目标容器开始迭代器

void test01()
{
	vectorv;
	vectorv2;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
		v.push_back(i + 1);
	}

	vectorvTarget;
	vTarget.resize(v.size() + v2.size());
	merge(v.begin(), v.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget.begin(), vTarget.end(), Myprint);
	cout << endl;
}
5.3.4 reverse

功能： 将容器内元素进行反转

函数原型：reverse(iterator beg, iterator end);

//beg 开始迭代器

//end 结束迭代器

vectorv;
for (int i = 0; i < 10; i++)
{
    v.push_back(i);
}

reverse(v.begin(), v.end());

5.4 常用拷贝和替换算法

  • copy //容器内指定范围的元素拷贝到另一容器中
  • replace //将容器内指定范围的旧元素修改为新元素
  • replace_if //容器内指定范围满足条件的元素替换为新元素
  • swap //互换两个容器的元素
5.4.1 copy

功能： 容器内指定范围的元素拷贝到另一容器中

函数原型：copy(iterator beg, iterator end, iterator dest)

//beg 开始迭代器

//end 结束迭代器

//dest 目标起始迭代器

vectorv;
for (int i = 0; i < 10; i++)
{
    v.push_back(i);
}

vectorv1;
v1.resize(v.size());
copy(v.begin(), v.end(), v1.begin());

for_each(v1.begin(), v1.end(), Myprint);
cout << endl;
5.4.2 replace

功能： 将容器内指定范围的旧元素修改为新元素

函数原型：replace(iterator beg, iterator end, oldvalue, newvalue);

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
    
	//0替换为1
	replace(v.begin(), v.end(), 0, 1);
	for_each(v.begin(), v.end(), Myprint);
	cout << endl;
}
5.4.3 replace_if

功能： 容器内指定范围满足条件的元素替换为新元素

函数原型：replace_if(iterator beg, iterator end, _Pred, newvalue);

//beg 开始迭代器

//end 结束迭代器

//_Pred 谓词

//newvalue 替换的新元素

class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void Myprint(int val)
{
	cout << val << " ";
}

void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//大于5的元素替换为10
	replace_if(v.begin(),v.end(), GreaterFive(), 10);

	for_each(v.begin(), v.end(), Myprint);
	cout << endl;
}
5.4.4 swap

功能： 互换两个容器的元素

函数原型：swap(container c1, container c2);

//c1 容器1

//c2 容器2

5.5 常用算术生成算法

使用时包含头文件为#include

  • accumulate //计算容器元素累计总和
  • fill //向容器中添加元素
5.5.1 accumulate

功能： 计算区间内 容器元素累计总和

函数原型：accumulate(iterator beg, iterator end, value);

//beg 开始迭代器

//end 结束迭代器

//value 起始累加值

vectorv;
for (int i = 0; i <= 100; i++)
{
    v.push_back(i);
}

int total = accumulate(v.begin(), v.end(), 0);
cout << "total = " << total << endl;
5.5.2 fill

功能： 向容器中添加元素

函数原型：fill(iterator beg, iterator end, value);

//beg 开始迭代器

//end 结束迭代器

//value 填充的值

vectorv;
v.resize(10);	//默认填充为0

//后期重新填充
fill(v.begin(), v.end(), 10);

5.6 常用集合算法

  • set_intersection //求两个容器的交集
  • set_union //求两个容器的并集
  • set_difference //求两个容器的差集
5.6.1 set_intersection

功能： 求两个容器的交集

注：两个集合必须是有序序列

函数原型：

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iteratior dest);

void test01()
{
	vectorv;
	vectorv2;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
		v2.push_back(i + 5);
	}

	vectorvTarget;
	vTarget.resize(min(v.size(), v2.size()));
	vector::iterator itEnd = set_intersection(v.begin(), v.end(), 
								v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, Myprint);
	cout << endl;
}
5.6.2 set_union

功能： 求两个集合的并集

注：两个集合必须是有序序列

函数原型：

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iteratior dest);

void test01()
{
	vectorv;
	vectorv2;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
		v2.push_back(i + 5);
	}

	vectorvTarget;
	vTarget.resize(v.size() + v2.size());
	vector::iterator itEnd = set_union(v.begin(), v.end(), v2.begin(), v2.end(), 
									vTarget.begin());
	for_each(vTarget.begin(), itEnd, Myprint);
	cout << endl;
}
5.6.3 set_difference

函数原型：

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iteratior dest);

void test01()
{
	vectorv;
	vectorv2;

	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
		v2.push_back(i + 5);
	}

	vectorvTarget;
	vTarget.resize(max(v.size(), v2.size()));
	cout << "v和v2的差集为：" << endl;
	vector::iterator itEnd = set_difference(v.begin(), v.end(), v2.begin(), v2.end(), 
									vTarget.begin());
	for_each(vTarget.begin(), itEnd, Myprint);
	cout << endl;
}

你可能感兴趣的:(c++,学习,笔记)

  • 随机近似算法：步长序列选择的理论与金融实践
    随机近似算法：步长序列选择的理论与金融实践摘要随机近似算法作为统计学习与优化的核心工具，其收敛性与稳定性高度依赖步长序列的设计。本文系统阐述步长序列的理论约束与工程选择策略，并结合金融波动率估计场景，展示算法在动态系统参数估计中的实践价值。1.随机近似算法的数学框架随机近似算法通过随机样本的迭代更新逼近目标参数，其核心迭代式为：θn+1=θn+an(Yn−g(θn))\theta_{n+1}=\t
  • DAY 43 复习日 yizhimie37 python训练营打卡笔记深度学习
    @浙大疏锦行https://blog.csdn.net/weixin_45655710第一步：寻找并准备图像数据集在Kaggle等平台上，你可以找到大量用于图像分类任务的数据集，例如英特尔图像分类数据集(IntelImageClassification)或手写数字识别数据集(DigitRecognizer)。对于初学者，一个更便捷的选择是使用像TensorFlow或PyTorch这样深度学习框架内
  • 浏览器的垃圾回收机制 甘露寺 js浏览器javascript前端
    深入解析现代浏览器的垃圾回收机制：分代回收与标记清除算法本文详细探讨了Chrome、Firefox等现代浏览器中JavaScript引擎的垃圾回收（GC）原理，重点讲解分代回收策略和标记清除/整理算法的工作流程，并通过示例帮助理解内存自动管理背后的机制。为什么需要垃圾回收？JavaScript是一种自动内存管理的语言。开发者通常不需要手动分配或释放内存（如C/C++中的malloc/free）。这
  • Bagel: 开源协作式AI数据管理平台的使用指南 llzwxh888 人工智能python
    Bagel:开源协作式AI数据管理平台的使用指南引言在人工智能和机器学习领域，高质量的数据集对于模型训练和推理至关重要。Bagel作为一个开源的协作式AI数据管理平台，为开发者和研究人员提供了一个强大的工具，用于创建、共享和管理推理数据集。本文将深入探讨Bagel的特性、安装方法以及如何使用它来处理和管理向量数据。Bagel简介Bagel（OpenInferenceplatformforAI）可以
  • 衡水中学状元数学学习资料完整攻略 向沙托夫问好
    本文还有配套的精品资源，点击获取简介：《状元全科笔记衡水内部资料数学学习文档》提供了一个全面的数学学习资源，旨在通过衡水中学的教学经验和方法提升学生的数学成绩。资料包含基础知识、题型解析、模块训练、思维拓展和学习方法，引导学生深入理解数学概念，培养逻辑思维和解决问题的能力。文档结构清晰，内容详实，附带使用指南，帮助学生系统提升数学素养，实现学习效率和成绩的双重提高。1.状元学习方法分享在追求卓越成
  • 在MATLAB中使用GPU加速计算及多GPU配置 东北豆子哥 CUDA数值计算/数值优化Matlab/Octavematlab
    文章目录在MATLAB中使用GPU加速计算及多GPU配置一、基本GPU加速使用1.检查GPU可用性2.将数据传输到GPU3.执行GPU计算二、多GPU配置与使用1.选择特定GPU设备2.并行计算工具箱中的多GPU支持3.数据并行处理（适用于深度学习）三、高级技巧1.异步计算2.优化GPU内存使用3.使用GPU加速函数四、注意事项在MATLAB中使用GPU加速计算及多GPU配置MATLAB提供了强大
  • React 元素渲染 小晗同学 Reactreactjsprops组件化
    React学习：元素渲染元素是构成React应用的最小砖块，它描述了你在屏幕上想看到的内容。constelement=Hello,world;与浏览器的DOM元素不同，React元素是创建开销极小的普通对象。ReactDOM会负责更新DOM来与React元素保持一致。React元素是不可变对象。一旦被创建，你就无法更改它的子元素或者属性。但是将元素或属性封装到有状态组件中，就可以实现更新渲染。Re
  • Solidity学习 - ABI 应用二进制接口 本郡主是喵 #Solidity学习区块链Solidity
    文章目录一、ABI基础概念1.ABI与API的区别2.ABI的核心作用二、ABI接口描述1.编译后的产物2.ABIJSON格式示例3.ABIJSON关键字段说明三、ABI编码1.编码示例2.编码数据的组成3.Solidity中的编码函数四、ABI解码1.解码的基本概念2.事件日志的解码五、ABI编解码可视化工具一、ABI基础概念1.ABI与API的区别API（应用程序接口）：是两个软件之间进行通信
  • Solidity学习 - 错误处理 本郡主是喵 #Solidity学习区块链Solidity
    文章目录前言EVM错误处理机制EVM错误处理的核心特性程序中的错误处理错误抛出方法require()函数require()触发异常的场景关键特性assert()函数assert()触发异常的场景关键特性require()vsassert()：选择指南revert()函数关键特性异常捕获：try/catch外部调用异常捕获高级异常捕获注意事项前言在Solidity智能合约开发中，错误处理是保障合约安
  • Solidity学习 - 断言失败 本郡主是喵 #Solidity学习区块链Solidity
    文章目录前言一、原理剖析（一）断言的作用（二）断言失败的影响（三）与require的区别二、案例分析（一）某去中心化金融（DeFi）借贷合约案例（二）某加密货币交易平台智能合约案例三、解决办法（一）正确区分assert和require的使用场景前言在Solidity智能合约开发领域，确保代码的稳健性和安全性是至关重要的。其中，断言失败漏洞是一个需要开发者高度警惕的问题，它可能会对智能合约的正常运行
  • ADIOS2 介绍与使用指南 东北豆子哥 HPC/MPIHPC
    文章目录ADIOS2介绍与使用指南什么是ADIOS2?ADIOS2的主要特点ADIOS2核心概念ADIOS2安装Linux系统安装Windows安装ADIOS2基本使用C++示例Python示例ADIOS2高级特性并行I/O流模式ADIOS2引擎类型性能优化建议总结ADIOS2介绍与使用指南什么是ADIOS2?ADIOS2(AdaptableInputOutputSystemversion2)是一
  • Solidity学习 - 代理模式中的初始化漏洞 本郡主是喵 #Solidity学习区块链Solidity
    文章目录前言一、原理剖析（一）代理模式基础（二）初始化流程概述（三）初始化漏洞成因二、案例分析（一）某DeFi借贷平台攻击事件（二）某NFT市场平台漏洞事件三、解决办法（一）严格权限控制（二）防止重入机制前言在Solidity智能合约开发中，代理模式因其强大的可升级性与灵活性，成为了众多项目的首选架构方案。通过将合约的逻辑实现与存储分离，开发者能够在不改变合约地址（从而不影响用户交互）的前提下，对
  • SqlServer基础学习笔记 @半夏微凉科技 技术拓展#sqlserversqlserver数据库学习笔记sqlServer学习笔记
    SqlServer基础学习笔记介绍了SQLServer数据库管理系统的基础知识，包括数据库的创建、表的设计、SQL查询语句、数据类型、索引、以及常见的管理任务等内容，适合初学者入门学习。第一章：SQLServer简介1.1SQLServer概述SQLServer是由Microsoft公司开发的关系型数据库管理系统，用于存储和管理大量数据。它提供了可靠性、安全性和高性能的数据库解决方案，广泛应用于企
  • CIANNA由天体物理学家提供/为天体物理学家提供的卷积交互式人工神经网络 struggle2025 神经网络
    一、软件介绍文末提供程序和源码下载CIANNA是一个通用的深度学习框架，主要用于天文数据分析。根据天体物理问题解决的相关性添加功能和优化。CIANNA可用于为各种任务构建和训练大型神经网络模型，并提供高级Python接口（类似于keras、pytorch等）。CIANNA的特点之一是它定制实施了受YOLO启发的对象探测器，用于2D或3D射电天文数据产品中的星系探测。该框架通过低级CUDA编程完全实
  • 嵌入式笔记：常用接口之详解I2C总线 失落的多巴胺 STM32网络单片机
    I2C(Inter-IntegratedCircuit)1.简介I2C(也称为IIC)是一种同步、多主、低速的串行通信协议，只需要两根线即可实现设备之间的数据传输，广泛应用于各种嵌入式设备中，这点在下文原理部分会进一步介绍。2.原理与特性1.双线通信I2C总线由两根信号线组成：SCL：即时钟线，由主设备（Master）产生时钟信号，用于同步数据传输。SDA：即数据线，用于主设备与从设备（Slave
  • WPF 几种绑定 (笔记) 菜长江 wpf
    资源与绑定DataContext（绑定到我们定义的属性）xmlns:local="clr-namespace:模板"以上仅仅是代表放了一个"ViewModel字典"完整引用是"模板\MyViewModel\SharedViewModel"然后并没有去使用它然后要想使用它就得通过指定"Source="{StaticResourceSharedViewModel}"这样就表示Grid绑定上下文对象是我
  • 嵌入式环境下的C++最佳实践 is0815 c++开发语言
    目标：学习嵌入式环境下的C++最佳实践内存管理优化：避免动态分配为什么避免动态分配？堆内存分配（如malloc,new）开销大，速度慢。堆内存容易导致碎片化，增加内存压力。动态分配增加内存泄漏、使用后未释放等风险。实时、高性能系统（嵌入式、游戏引擎）尤其需要优化内存管理。栈vs堆的性能对比特性栈(stack)堆(heap)分配/释放速度极快(O(1))较慢(需管理分配表，O(logn)或更慢)生命
  • 简说 MISRA-C++ is0815 c++
    MISRA-C++是嵌入式系统中广泛采用的C++编码规范，旨在提高代码安全性、可靠性和可维护性。以下是MISRA-C++的详细要求，涵盖核心规则分类、禁用特性及最佳实践：一、核心规则分类1.语言使用限制禁用动态内存分配（new/delete、std::malloc）风险：内存碎片、分配失败导致运行时崩溃替代：静态数组、对象池或定制内存分配器禁用异常处理（try/catch/throw）风险：异常展
  • Linux-笔记 设备树插件 FU.l 笔记驱动开发linux
    目录前言：设备树插件的书写规范：设备树插件的编译：内核配置:应用背景：举例：前言：设备树插件（DeviceTreeBlobOverlay，简称DTBO）是Linux内核和嵌入式系统中用于动态修改或扩展系统运行时的设备树配置的一种机制。它是对传统设备（DeviceTreeSource，简称DTS）的补充，允许在不重新编译整个内核的情况下，对硬件配置进行更改。本质也是个设备树文件。设备树插件的书写规范
  • 【5步通关！】C#企业级知识库实战——从0到1打造智能知识共享平台的魔法指南！ 墨瑾轩 一起学学C#【三】c#开发语言
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣你的团队还在用“纸质文件+Excel”管理知识？或者想让员工像“知识魔法师”一样秒速找到所需信息？今天，我们将用5个“魔法步骤”，手把手教你用C#打造企业级知识共享平台！无论你是“技术小白”还是“架构老司机”，这篇文章都将为你揭秘如何让知识库像“超级搜索引擎”
  • PAT A1052 Linked List Sorting C++ 主要的坑 sisi-mia PAT甲级算法c++学习pat考试
    Alinkedlistconsistsofaseriesofstructures,whicharenotnecessarilyadjacentinmemory.WeassumethateachstructurecontainsanintegerkeyandaNextpointertothenextstructure.Nowgivenalinkedlist,youaresupposedtosortt
  • c# 核心技术指南——第2章 c# 语言基础 伦比兔 C#核心技术指南c#开发语言
    本书中几乎所有的程序和代码片段都可以作为交互式示例在LINQPad中运行。阅读本书时使用这些示例可以加快你的学习进度。在LINQPad中编辑执行这些示例可以立即得到结果，无须在VisualStudio中建立项目和解决方案。2.1第一个C#程序在C#中，语句按顺序执行，每个语句都以分号结尾。类将函数成员和数据成员聚合在一起形成面向对象的构建单元。Console类将处理命令行的输入输出功能聚合在一起，
  • java 学习 底层代码 算法 好学且牛逼的马 java
    #33写算法题黑马的视频争取简单的过一遍要考试啦密码的写底层代码秘密的底层代码有点长啊看不懂难找了几个视频课看看吧想看中文版jdkapi吧算了慢慢看先把几个顶级父类给看会了objectsystemstringstringbuilder算法单路递归packagecom.itheima.Recursion;​publicclasssingleRecursion{  publicstaticvoidma
  • Java web%10 好学且牛逼的马 java前端AI编程
    %10新路线Javawebai笔记阶段时长内容Web前端基础2天HTML、CSS、JS、Vue3、AjaxWeb后端基础4天Maven、HTTP协议、SpringIOC、DI、MySQL、JDBC、MybatisWeb后端实战6天Tlias案例（基于案例讲解web开发的核心知识）Web后端进阶2天SpringAOP、SpringBoot原理、自定义Starter、Maven高级前端web实战4天V
  • Java 集合list 手搓底层源码 好学且牛逼的马 算法
    #32Java八股集合基础用法掌握速通小林不是很全老韩详细底层byd课程质量一般八股文听书算法题不会写byd密码的还没开始看双指针技巧秒杀七道链表题目|labuladong的算法笔记等等熬夜看笔记实现底层代码后面非常长但是也只写到了list完map和set明天写collection这段代码展示了Java集合框架的核心接口层次结构。`Collection`是整个集合框架的根接口，定义了集合操作的基本
  • VSCode更改程序编译之后生成文件的保存路径 一low永逸 安装IDEvscode
    目录目标过程如何生成json代码其他参考目标想把程序文件和生成文件分开来，生成在当前文件的out文件夹过程在保存代码的文件夹下面再建一个保存生成文件的文件夹，我生成了out文件夹打开.vscode文件夹下面settings.json文件（这个json文件可以自己生成或复制过来，不影响使用）在settings.json中加入以下代码，我主要使用C++语言，所以只改这个，不同系统的shell语法不一样
  • PettingZoo:多智能体强化学习的标准API 资源存储库 多智能体强化学习人工智能深度学习
    PettingZoo:AStandardAPIforMulti-AgentReinforcementLearningPettingZoo:多智能体强化学习的标准API目录Abstract摘要1Introduction1介绍2BackgroundandRelatedWorks2背景及相关工作2.1PartiallyObservableStochasticGamesandRLlib2.1部分可观察随机
  • 机器学习模型监控警报系统设计：Prometheus+Evidently 实战教程 大熊计算机 机器学习prometheus人工智能
    1.系统架构设计：从数据采集到智能告警（1）监控系统核心组件交互图预测请求监控指标告警规则通知渠道预测结果质量报告时序数据模型服务PrometheusExporterPrometheusServerAlertmanager邮件/Slack/WebhookEvidently服务可视化仪表盘图解：系统采用双引擎架构，Prometheus负责基础监控指标采集与告警触发，Evidently执行深度模型分析
  • 浅谈Qt和C++的关系 Terrarily qt5qtc++
    Qt和C++Qt是QML和JavaScript的C++扩展功能工具包，并且Qt是由C++开发的，所以C++贯穿了整个Qt的项目。我会着重从c++的角度来介绍Qt。从C++的角度分析Qt，然后你会发现Qt通过内省数据的机制实现了许多现代语言的特性。这个是通过Qt的基础类QObject来实现的。Qt使用源对象信息实现了信号和槽的回调绑定。每个信号都能绑定任意数量的槽函数或者其他的信号。当一个信号弄一个
  • C++使用大小括号初始化变量 空名Noname c++开发语言
    转自个人博客本文对普通变量、普通类对象在初始化时使用()和{}的情况进行区分说明，以免混淆不清。一般使用()是使用构造函数初始化，使用{}是使用列表初始化，如下。1.基本初始化（略过）这里大概对基本初始化方式做一个归纳1.1默认初始化即只声明，让其调用默认构造函数。对于基本变量类型（如int、double…），只声明就不会定义具体的初始值。对于类对象，就会调用可以不用填参数的默认构造函数，如果没有
  • apache 安装linux windows 墙头上一根草 apacheinuxwindows
    linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式     通过二进制文件安装Apache需要的软件有apr,apr-util,pcre  1，安装 apr        下载地址：htt
  • fill_parent、wrap_content和match_parent的区别 Cb123456 match_parentfill_parent
    fill_parent、wrap_content和match_parent的区别:   1）fill_parent   设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。 2） wrap_conte
  • 网页自适应设计 天子之骄 htmlcss响应式设计页面自适应
    网页自适应设计        网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
  • [sql server] 分组取最大最小常用sql 一炮送你回车库 SQL Server
    --分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
  • ImageIO写图片输出到硬盘 3213213333332132 javaimage
    package awt; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imagei
  • 自己的String动态数组 宝剑锋梅花香 java动态数组数组
    数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10];    但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？  动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
  • pinyin4j工具类 darkranger .net
    pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小 引入pinyin4j-2.5.0.jar包: pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。 本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
  • StarUML学习笔记----基本概念 aijuans UML建模
    介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。         模型、视与图（Model, View and Diagram）        &
  • Activiti最终总结 avords Activiti id 工作流
    1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。 2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。 3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。 4、TaskDefinitionKey和（ActivityImpl activityId
  • 从省市区多重级联想到的，react和jquery的差别 bee1314 jqueryUIreact
    在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。   针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
  • Eclipse快捷键大全 bijian1013 javaeclipse快捷键
    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
  • js 笔记 函数 征客丶 JavaScript
    一、函数的使用 1.1、定义函数变量 var vName = funcation(params){ } 1.2、函数的调用 函数变量的调用：      vName(params); 函数定义时自发调用：(function(params){})(params); 1.3、函数中变量赋值 var a = 'a'; var ff
  • 【Scala四】分析Spark源代码总结的Scala语法二 bit1129 scala
    1. Some操作   在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量， Some的文档说明：   /** Class `Some[A]` represents existin
  • java 匿名内部类 BlueSkator java匿名内部类
    组合优先于继承 Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系 继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。   在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。 内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
  • 盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用 ljy325 游戏applewindowsXPOS
    Mac mini 型号: MC270CH-A RMB:5,688   Apple 对windows的产品支持不好,有以下问题:   1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响!   2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高 &nbs
  • 读《研磨设计模式》-代码笔记-生成器模式-Builder bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF） * 个人理解： * 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
  • JIRA与SVN插件安装 chenyu19891124 SVNjira
    JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。 1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1) 2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
  • 常用数学思想方法 comsci 工作
      对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考   函数思想 　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
  • pl/sql集合类型 daizj oracle集合typepl/sql
    --集合类型 /*   单行单列的数据，使用标量变量   单行多列数据，使用记录   单列多行数据，使用集合（。。。）   *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等 */ /*     --集合方法 &n
  • [Ofbiz]ofbiz初用 dinguangx 电商ofbiz
    从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用 1. 加载测试库 ofbiz内置derby，通过下面的命令初始化测试库 ./ant load-demo (与load-seed有一些区别)   2. 启动内置tomcat ./ant start 或 ./startofbiz.sh 或 java -jar ofbiz.jar &
  • 结构体中最后一个元素是长度为0的数组 dcj3sjt126com cgcc
    在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag {     __u16 tag_type;     __u16 tag_len;   &n
  • Linux cp 实现强行覆盖 dcj3sjt126com linux
    发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。 方法一 我们输入alias命令，看看系统给cp起了一个什么别名。 [root@localhost ~]# aliasalias cp=’cp -i’a
  • Memcached(一)、HelloWorld frank1234 memcached
    一、简介 高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。 二、客户端 选择一个memcached客户端，我这里用的是memc
  • Search in Rotated Sorted Array II hcx2013 search
    Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given ta
  • Spring4新特性——更好的Java泛型操作API jinnianshilongnian spring4generic type
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装JDK liuxingguome centos
    1、行卸载原来的： [root@localhost opt]# rpm -qa | grep java tzdata-java-2014g-1.el6.noarch java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64 java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64 [root@localhost
  • 二分搜索专题2-在有序二维数组中搜索一个元素 OpenMind 二维数组算法二分搜索
    1,设二维数组p的每行每列都按照下标递增的顺序递增。 用数学语言描述如下：p满足 (1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y); (2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2); 2,问题： 给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k? 3,算法分析： (
  • java 随机数 Math与Random SaraWon javaMathRandom
    今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是 http://www.oschina.net/question/157182_45274?sort=default&p=1#answers 产生1到10之间的随机数的两种实现方式： //Math Math.roun
  • oracle创建表空间 tugn oracle
    create temporary tablespace TXSJ_TEMP   tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf'   size 32m   autoextend on   next 32m maxsize 2048m   extent m
  • 使用Java8实现自己的个性化搜索引擎 yangshangchuan javasuperword搜索引擎java8全文检索
    需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下： 1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。 2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。 3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他