C++全系列学习（基础篇）_c++学习

一、基础语法

1、数据类型

基本数据类型：

复合数据类型：

引例：

int a = 10;
cout<<sizeof(a)<<endl; //统计该变量所占内存大小
 
//科学计数法
float a = 3e2; //表示3*10^2
float a = 3e-2; //表示3*10^-2
 
//字符串
a = 'b'
a = "b"
a = "hello" //单个字符时可用''或"",字符串只能用""
 
//转义字符
cout<<"hello\n"<<endl; \n为换行符
 
cout<<"aa\thello"<<endl;
cout<<"aaaa\thello"<<endl;
cout<<"a\thello"<<endl; //\t为水平制表符，可整齐输出数据
 

2、运算符

算数运算符

/可以是两个小数相除，若是两个整数相除则结果向下取整

%为取模

递增递减

所谓前置就是先加1，后置就是先运算

逻辑运算符

3、数组

一维数组

3种定义方式：

1）数据类型 数组名[数组长度]；

2）数据类型 数组名[数组长度] = {值1，值2，……}

注意：若实际值与长度不同时，自动用0补足

3）数据类型 数组名[] = {值1，值2，……}

int arr[10];
arr[0] = 1;
 
int arr2[4] = {1,2,3,4};
 
int arr3[] = {1,2,3};

获取首地址

两种方式：arr或&arr[0]

数组长度统计

数组占用内存空间大小：sizeof(arr)
数组单个元素占用内存空间大小：sizeof(arr[0])
数组长度：sizeof(arr) / sizeof(arr[0])

冒泡排序（后文具体介绍）

1. 比较相邻元素： 从第一个元素开始，比较相邻的两个元素，如果它们的顺序不正确（比如在升序排序中，前一个元素大于后一个元素），则交换它们。

2. 一次遍历完成： 经过一次遍历，最大（或最小）的元素会被移到序列的最后位置。

3. 重复步骤1和2： 重复进行上述步骤，直到序列完全有序。在每次遍历中，待排序序列的长度减一，因为每次遍历都会将一个元素放置到了正确的位置上

二维数组

定义方式

二维数组定义的4种方式：

1）数据类型 数组名[ 行数 ][ 列数 ];

2）数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2} ，{数据3，数据4} };

3）数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};

4）数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4}

注意：常用第二种，可读性较强

int array2D[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
cout << "Array elements:" << endl;
for(int i = 0; i < 3; ++i) {
    for(int j = 0; j < 3; ++j) {
        cout << array2D[i][j] << " ";
    }
    cout << endl;
}
 
Array elements:
1 2 3
4 5 6
7 8 9

计算行数与列数

二维数组的行数：sizeof(arr) / sizeof(arr[0])

二维数组的列数：sizeof(arr[0]) / sizeof(arr[0][0])

地址

二维数组首地址：arr[0] 或 &arr[0][0]

二维数组第1个元素的地址： arr[0] 或 &arr[0][0]

二维数组第 0 行的地址： arr或arr[0]或arr + 0 

二维数组第 i 行的地址：arr[i]或arr + i

二维数组第 i 行首元素的地址：arr[i]或arr + i或*(arr + i)或&a[0] + i

二维数组第 i 行第 j 列元素的地址：&arr[i][j]或*(arr + i) + j

4、循环

for循环

#include<bits/stdc++.h>
using namespace std;
int main ()
{   int sum=0;
    for (int i=1; i<=100 ; ++i)    
       sum+=i;
    cout<<sum;
    return 0;
} 

while循环

while（表达式）语句；

while（表达式）{

    语句1；

    语句2；

}

例：用while打印数组

#include <iostream>
using namespace std;
 
int main() {
    int array[] = {1, 2, 3, 4, 5};
    int length = sizeof(array) / sizeof(array[0]); // 计算数组的长度
 
    cout << "Array elements: ";
    int i = 0; // 初始化计数器
    while (i < length) {
        cout << array[i] << " ";
        i++; // 更新计数器
    }
    cout << endl;
 
    return 0;
}

do-while循环

do{

    语句1；

    语句2；

}

while（条件表达式）

示例：获取输入，直到输入的值为正数为止

#include <iostream>
using namespace std;
 
int main() {
    int num;
 
    do {
        cout << "请输入一个正数：";
        cin >> num;
    } while (num <= 0);
 
    cout << "你输入的正数是：" << num << endl;
 
    return 0;
}

while和do-while的区别：

1. while 循环：

   • 在 while 循环中，循环条件会在每次循环开始之前被检查。如果条件为真，循环体会执行，然后再次检查条件。如果条件为假，循环终止。
   • 这意味着，如果条件一开始就为假，循环体可能一次都不会执行。

2. do-while 循环：

   • 在 do-while 循环中，循环体会先执行一次，然后再检查循环条件。只要条件为真，循环体会继续执行，否则循环终止。
   • 这意味着，do-while 循环至少会执行一次循环体，即使条件一开始就为假。

嵌套循环

示例：水仙花数字

#include<bits/stdc++.h>
using namespace std;
int main()
{  for (int a=1; a<=9; ++a)
      for (int b=0; b<=9; ++b)
         for (int c=0; c<=9; ++c)
           { if (a*a*a+b*b*b+c*c*c==a*100+b*10+c) 
               cout<<setw(6)<<a*100+b*10+c;   //setw函数控制输出场宽
           }
    return 0;
}

5、条件语句（if）

单行格式if

#include <iostream>
using namespace std;
 
int main() {
    int num;
 
    cout << "请输入一个整数：";
    cin >> num;
 
    if (num > 0) {
        cout << "这是一个正数。" << endl;
    }
 
    return 0;
}

多行格式if

#include <iostream>
using namespace std;
 
int main() {
    int num;
 
    cout << "请输入一个整数：";
    cin >> num;
 
    if (num > 0) {
        cout << "这是一个正数" << endl;
    }
 
    else if (num == 0){
        cout << "0" << endl;
    }
 
    else{
        cout << "这是一个负数" << endl;
    }
    return 0;
}

6、结构体

语法

struct 结构体名 { 结构体成员列表 }；

结构体创建变量

#include <iostream>
using namespace std;
 
// 定义一个名为 Person 的结构体
struct Person {
    string name;
    int age;
    double height;
};
 
int main() {
    // 创建一个 Person 类型的对象
    struct Person person1;
 
    // 给结构体成员赋值
    person1.name = "Alice";
    person1.age = 30;
    person1.height = 5.6;
 
    // 输出结构体成员的值
    cout << "Name: " << person1.name << endl;
    cout << "Age: " << person1.age << endl;
    cout << "Height: " << person1.height << endl;
    
    struct Person person2 = {"BEN",40,4.4};
 
    return 0;
}

结构体数组

#include <iostream>
#include <string>
using namespace std;
 
// 定义一个名为 Person 的结构体
struct Person {
    string name;
    int age;
    double height;
};
 
int main() {
    // 使用大括号初始化结构体数组
    Person people[3] = {
        {"Alice", 30, 5.6},
        {"Bob", 25, 6.0},
        {"Charlie", 35, 5.9}
    };
 
    // 输出结构体数组中每个结构体的成员值
    for (int i = 0; i < 3; ++i) {
        cout << "Person " << i+1 << ":" << endl;
        cout << "Name: " << people[i].name << endl;
        cout << "Age: " << people[i].age << endl;
        cout << "Height: " << people[i].height << endl;
        cout << endl;
    }
 
    return 0;
}

结构体指针

#include <iostream>
using namespace std;
 
// 定义一个名为 Person 的结构体
struct Person {
    string name;
    int age;
    double height;
};
 
int main() {
    // 创建一个 Person 类型的结构体指针
    struct Person* p = new Person;
 
    // 使用 -> 运算符给结构体成员赋值
    p->name = "Alice";
    p->age = 30;
    p->height = 5.6;
 
    // 使用 -> 运算符访问结构体成员并输出
    cout << "Name: " << p->name << endl;
    cout << "Age: " << p->age << endl;
    cout << "Height: " << p->height << endl;
 
    // 记得释放动态分配的内存
    delete p;
 
    return 0;
}

结构体嵌套

结构体中成员是另一个结构体

7、函数

主函数为main（），但可以创作其他函数进行运算，只需在主函数中调用即可，以下以阶乘为例

#include <iostream>
 
using namespace std;
 
int factorial(int n){
    if(n==1)
        return n;
    else
        return n*factorial(n-1);
}
 
int main()
{
    int n;
    cout << "请输入整数:" << endl;
    cin >> n;
    cout << "整数:" << n << "的阶乘为:" << factorial(n) << endl;
    cout << "\n" << endl;
    return 0;
}

二、STL库

STL（Standard Template Library）是 C++ 标准库的一部分，它提供了一组通用的模板类和函数，用于实现常见的数据结构和算法。STL 的设计旨在提供一种高效、灵活和可重用的方法来处理数据结构和算法问题。总的来说，STL库装了许多算法和组件，包含多种函数，可用于开发各类应用程序

1、快速排序（Sort）

基本用法

格式：

void sort（起始地址，结束地址，比较函数）；

#include<algorithm>
#include<iostream>
using namespace std;
int main(){
	int a[] = {2,3,5,4,1,8,6,9};
	sort(a,a+8);//a为数组的开头，a+8就等于排序到数组的第8个元素
	for(int i=0;i<6;i++)
		cout<<a[i]<<" ";
	
} 

cmp用法

在sort比较函数中传入排序函数，>为降序，<为升序

#include<algorithm>
#include<iostream>
using namespace std;
 
bool cmp(int x,int y)
{
	if(x>y)return true;//降序
	return false;
}
 
int main(){
	int a[] = {2,3,5,4,1,8,6,9};
	sort(a,a+8,cmp);//a为数组的开头，a+8就等于排序到数组的第8个元素
	for(int i=0;i<6;i++)
		cout<<a[i]<<" ";
	
} 

2、关联容器（Map）

map是一个关联容器，它提供了一种将键与值关联起来的方式,map中的每个元素都是一个键（key-value pair），其中键（key）是唯一的，值（value）则可以不唯一。它基于红黑树（Red-Black Tree）实现。

注意：map不允许容器中有重复的key值，multimap允许容器中有重复的key

格式：

map（数据类型，数据类型）一个自定义的名称；

#include <iostream>
#include <map>
 
int main() {
    map<string, int> phonebook;
 
    phonebook["Alice"] = 123456;
    phonebook["Bob"] = 789012;
    phonebook["Charlie"] = 345678;
 
    cout << "Bob's phone number: " << phonebook["Bob"] << endl;
 
    phonebook["Alice"] = 111111;
    phonebook.erase("Charlie");
 
    // 遍历元素
    for (const auto& pair : phonebook) {
        cout << pair.first << "'s phone number: " << pair.second <<endl;
    }
 
    return 0;
}

1）构造

2）赋值

3）大小和交换

4）插入和删除

5）查找和统计

3、栈（stack）

相当于是一个小箱子，每次向箱子顶部塞入数据，遵循先进后出（Last In, First Out，LIFO）的原则。栈可以被看作是一种容器，其中元素按照后进先出的顺序进行插入和删除。

格式：

#include<stack>
stack<数据类型>一个自定义的名字；
或：
stack 一个自定义的名字；

栈的成员函数

代码示例：

#include<stack>
#include<iostream>
using namespace std;
stack<int> st;
int main(){
    
    st.push(1);
    st.push(2);
    st.push(3);
    cout<<st.top();
    return 0;
}
 
输出：
3

4、动态数组容器（Vector)

使用的时候可以看作数组，但他相对于数组来说可以动态扩展，增加长度

1）构造

头文件：#include<vector>
构造：vector<T> v ;
放入数据：v.push_back(…)；
迭代器：vector<int>::iterator
将[v.begin(),v.end())区间中的元素拷贝给本身：vector(v.begin(),v.end());
将n个elem拷贝给本身:vextor(n,elem);
拷贝构造函数:vector(const vector &v) ;

void printVector(vector<int>& v)
{	//利用迭代器打印 v
	for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
 
void text01()
{
	vector<int> v1;                       
	for (int i = 0; i < 5; ++i)
	{
		v1.push_back(i);//向v1末尾添加数据
	}
	vector<int> v2(v1.begin(), v1.end()); //构造2
	vector<int> v3(5, 5);                 //构造3
	vector<int> v4(v3);                   //构造4
                 
	cout << "打印v2: ";
	printVector(v2);
	cout << "打印v3: ";
	printVector(v3);
	cout << "打印v4: ";
	printVector(v4);
}

2）遍历

第一种遍历方式

vector<int>::iterator pBegin = v.begin();
vector<int>::iterator pEnd = v.end();
 
while(pBegin != pEnd){
    cout<<*pBegin<<endl;
    pBegin++;
}

第二种遍历方式

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

3）赋值

void printVector(vector<int>& v)
{	//利用迭代器打印 v
	for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
 
void text02()
{
	vector<int> v1,v2;
	for (int i = 0; i < 5; ++i)
	{
		v1.push_back(i);
	}
 
	v2 = v1;                        
	vector<int> v3,v4;
	v3.assign(v1.begin(), v1.end())；
	v4.assign(10，100);                
 
	cout << "打印v2: ";
	printVector(v2);
	cout << "打印v3: ";
	printVector(v3);
	cout << "打印v4: ";
	printVector(v4);
}
 
 

4）容量和大小

5）插入和删除

6）数据存取

7）互换容器

v1.swap(v2)

8）预留空间

当数据量较大时可以一开始就利用reserve预留空间

5、String

string内部封装了许多成员方法，如find，copy，delete，insert，replace等

头文件：#include<string>

1）构造

#include<string>
void test1(){
    string s1; //创建空字符串，使用无参构造函数
    
    const char*str = "hello";
    string s2(str);
 
    string s3(s2); //调用拷贝构造函数
 
    string s4(10,'a'); //将字符a复制10次    
 
    string s5(s2,1);//拷贝s2所指向的字符串序列的第1个到结尾的字符
 
}

2）赋值

3）字符串插入、拼接和删除

插入：

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string s0("");
	s0.push_back('a');//s0尾插入a
 
	string s1("b");
	s0.insert(1, s1);//在下标为1的位置插入s1的拷贝
 
	s0.insert(4, "c");//在下标为4的位置插入字符串o
 
    s0.insert(0, "hello",2);//在下标为0的位置插入"hello"的前2个字符
 
    return 0;
}

拼接：

删除：

str.erase(1,3); //从1号位置开始删除3个字符

4）查找和替换

注意：

find是从左往右查找，rfind是从右往左查找

find找到字符串后返回查找的第一个字符位置，找不到就返回-1

replace在替换时，要指定从哪个位置起，替换多少个字符，替换成什么

5）字符串的比较

注意：若=则返回0，>返回1，<返回-1

int main(){
 
    string s1="hello";
    string s2="hhllo";
 
    int ret = s1.compare(s2);
    
    ……
    return 0;
}

6）字符串存取

int main(){
 
    string str = "hello world"
 
    for (int i = 0;i < str.size();i++){
 
        cout << str[i] << " ";
        cout << str.at(i) << " ";
    }
 
    cout<<endl;
}
 
//字符修改：
    str[0] = "x";
    str.at(1) = "x";
 
    return 0;
}

7)子串

void teste1(){
    string str ="abcdefg"；
    string substr = str.substr(1,3)
    cout<<"substr ="<< substr << endl;
 
    string email="hello@sina.com";
    int pos = email.find("@");
    string username =email.substr(0, pos);
    cout<<"username:"<<username<< endl
}
 
int main(){
    teste1();
    system("pause");
    return0;
}

6、Set

基本概念：以有序的方式存储一组唯一的元素。具体来说，std::set使用红黑树（Red-Black Tree）实现，这使得元素在插入时就会按照特定的顺序进行排序，并且保证了查找、插入和删除操作的高效性能。

注意：set不允许容器出现重复元素，multiset允许容器出现重复元素

头文件：#include<set>

遍历：

#include <set>
 
void printSet(set<int> &s){
    for(set<int>::iterator it=s.begin();it!=s.end;it++){
        cout<<*it<<" ";
    }
    cout<<endl;
}

1）构造和赋值

set<int> s1;
 
s1.insert(10);
s1.insert(10);
 
set<int>s2(s1); //拷贝构造
 
set<int> s3;
s3=s2; //赋值

2）大小和交换

set<int> s1;
s1.insert(10);
s1.insert(20);
s1.insert(30);
 
set<int> s2;
s1.insert(40);
s1.insert(50);
s1.insert(60);
 
s1.swap(s2);

3）插入和删除

set<int> s1;
 
s1.insert(10);
s1.insert(20);
s1.insert(30);
 
s1.erase(s1.begin()); //删除
s1.erase(10);
 
s1.clear(); //清空
 

4）查找和统计

7、Queue

先进先出的数据结果，有两个出口，只有队头和队尾能被外界访问，因此不存在遍历的行为

1）构造函数

2）赋值

3）数据存取

4）大小

三、字符串

1、简介

C语言风格：

char a[5] = {'1','2','3','4','5'};   //字符数组
char b[5] = {'1','2','3','4','\0'};  //字符串
 
char greeting['h','e','l','l','o','\0'}; //字符串
char greeting[]="hello";
 
//输出结果为 hello

C++引入的string类类型（函数及其目的）

2、字符串的读入

1）对字符数组得输入方法

1.1cin使用空白字符作为一次输入的结尾，并忽略该空字

char word[10];
cin >> word;
cout<<word;
 
//若输入123 456，只会输出123

该情况下只能输入一个单词，若输入了多个单词，只会取第一个单词，其余单词被忽略掉

1.2使用getline()/get()函数完成面向行的输入

区别：主要区别在于它们处理输入流的方式：getline() 用于读取整行并丢弃定界符，而 get() 则用于逐字符读取，并保留定界符在输入流中。

#cin.getline()

cin.getline(line,nums,(optional)delim)

nums：代表从该队列中获取nums-1个字符到line中（最后一个字符为\0）若超出nums-1，后面的都无法取到。

delim：指定分界符，表示遇到分界符后当前字符串的输入将停止，其后的会保留在输入队列中作为下一个字符串的开始。

int main(){
	char line1[10];
	char line2[10];
	cin.getline(line1,10,'s');	
	cin.getline(line2,10);
	cout<<line1<<endl;
	cout<<line2<<endl;
	return 0; 		
} 
 
//测试：123s456
//结果：
line1：123
line2：456

#cin.get()

cin.get(line,nums,(optional)delim)

get会在输入队列中保留最后的换行符，若不做处理可能出现问题，以下方式可以避免：

cin.get(line2,10).get();
 
cin.get(line2,10);
get();

1.3数字与字符串混合输入

	int a,b;
	char s[7];
	cin>>a;
	(cin>>b).get();
	cin.getline(s,7);
	cout<<a<<" "<<b<<" "<<s;
 
 
//测试：123 456 hello
结果：
123
456
hello
123 456 hello

2）对string对象的输入方法

string a
getline(cin,a);
cout<<a<<endl;

3、常见操作

1）常用函数

2）读写string

string s1,s2,s3;
cin>>s1;
cin>>s2>>s3;
 
//结果：
nice to meet
nice
to
meet

若要保留输入时的空格，可以使用getline

string s1;
getline(cin,s1);
 
//结果：
nice to meet
nice to meet

3）cctype头文件

4）用for循环完成cctype各项

#include<iostream>
#include<string>
#include<cctype>
using namespace std;
int main(void){
    string s1 = "hello world";
    for(auto &c : s1)
        c=toupper(c);
    cout<<s1<<endl;
    return 0;
}
 
//结果
HELLO WORLD

四、排序

1、冒泡排序

原理：比较前后两个数字的大小，大的放在后面，依次遍历所有数字

#include <iostream>
#define N 1010
using namespace std;
 
int n = 6;  //待排序的元素个数为6 
int a[N] = {0,2,3,2,11,7,6};  //待排序元素 
 
int main(){
    
    for(int i = 1;i<n;i++){  //连续交换过程
    //一共n-1个阶段，在第i个阶段，未排序序列长度从n-i+1到n-i 
        
        for (int j = 1;j<=n-i;++j)  //将序列从1到n-i+1的最大值移到n-i+1的位置 
            if (a[j] > a[j+1])  // 将序列从1到n-i+1的最大值，移到n-i+1的位置
                swap(a[j],a[j+1]);   // 其中j枚举的是前后交换元素的前一个元素序号
    }
    
    //输出 
    for (int i=1;i<=n;++i)
    cout<<a[i]<<' ';
    cout<<endl;
    return 0;
}

2、选择排序

原理：

1. 遍历数组，找到最小（或最大）的元素。
2. 将找到的最小（或最大）元素与数组的第一个元素交换位置。
3. 排除第一个元素，对剩余的元素进行相同的操作，即在剩余的未排序部分中找到最小（或最大）的元素，并与该部分的第一个元素交换位置。
4. 重复以上步骤，直到整个数组排序完成。

缺点：平均时间复杂度为O(n^2)，空间复杂度为O(1)，性能通常比较差。

#include <iostream>
#include <vector>
 
using namespace std;
 
// 选择排序函数
void selectionSort(vector<int>& arr) {
    int n = arr.size();
    
    
    for (int i = 0; i < n - 1; ++i) { // 外层循环遍历数组
        
        int minIndex = i; // 假设当前元素为最小值的索引
        
        // 内层循环寻找最小值的索引
        for (int j = i + 1; j < n; ++j) {
            
            if (arr[j] < arr[minIndex]) { // 如果找到更小的元素，则更新最小值的索引
                minIndex = j;
            }
        }
        
        
        swap(arr[i], arr[minIndex]); // 将最小值与当前位置的元素交换位置
    }
}
 
int main() {
    // 测试选择排序函数
    vector<int> arr = {64, 25, 12, 22, 11};
    
    cout << "Original array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;
    
    
    selectionSort(arr); // 调用选择排序函数
    
    cout << "Sorted array: ";
    for (int num : arr) {
        cout << num << " ";
    }
    cout << endl;
    
    return 0;
}

3、插入排序

原理：

1. 将数组视为两部分，一部分是已排序的部分，一部分是未排序的部分。
2. 从未排序部分取出第一个元素，在已排序部分中从后往前逐个比较，找到合适的位置插入该元素，使得插入后的部分仍然保持有序。
3. 重复上述过程，直到未排序部分为空，整个数组就排好序了。

优点：适合小型数据集或部分有序的数据。

#include<iostream>
using namespace std;
 
int main() {
    int a[6] = { 2, 6, 5, 3, 4, 1};  // 待排序序列 
    int temp, i, j;
    int n = 6;  // 待排序元素个数 
    
    // 开始插入排序
    for (i = 1; i < 6; i++) {  
        // 假定第一个数是有序的，从第二个数开始枚举
        temp = a[i]; // 临时储存每一次需要排序的数
        j = i;       // j用于记录当前待排序元素的位置
        // 在有序部分从后往前比较，将比当前元素大的元素往后移动
        while (j >= 1 && temp < a[j - 1]) {
            a[j] = a[j - 1]; // 元素往后移动
            j--;             // 继续向前搜索
        }
        a[j] = temp; // 将待排序元素插入到合适的位置
    }
    
    // 输出排序后的结果
    for (i = 0; i < 6; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}