C++相关基础知识-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45857607/article/details/141727288

          @[TOC](C++相关基础知识)

set

set 中的元素是不能重复的。set 是一种关联容器，它自动维护元素的唯一性，确保每个元素在集合中只出现一次。

特点：
唯一性：set 中的每个元素都是唯一的。如果你试图将一个已经存在的元素插入到 set 中，插入操作将不会改变集合内容。
自动排序（针对 std::set）：在 std::set 中，元素是按照某种顺序自动排序的，通常是从小到大（按照元素的 < 操作符）。
高效查找：由于 set 内部使用平衡二叉树（通常是红黑树）实现，因此查找、插入、删除操作的时间复杂度都是 O(log n)。

常用操作
insert(元素): 插入一个元素。
erase(元素): 删除一个元素。
find(元素): 查找一个元素。
size(): 返回容器中元素的数量。
empty(): 检查容器是否为空。

#include <iostream>
#include <set>

int main() {
    // 声明一个整型 set 容器
    std::set<int> mySet;

    // 插入元素
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(30);
    mySet.insert(40);

    // 输出 set 中的元素
    std::cout << "Set contains: ";
    for (int num : mySet) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 查找元素
    if (mySet.find(20) != mySet.end()) {
        std::cout << "20 is in the set." << std::endl;
    } else {
        std::cout << "20 is not in the set." << std::endl;
    }

    // 删除元素
    mySet.erase(20);

    // 再次输出 set 中的元素
    std::cout << "After erasing 20, set contains: ";
    for (int num : mySet) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 检查 set 是否为空
    if (mySet.empty()) {
        std::cout << "The set is empty." << std::endl;
    } else {
        std::cout << "The set is not empty." << std::endl;
    }

    // 输出 set 中元素的数量
    std::cout << "The set contains " << mySet.size() << " elements." << std::endl;

    return 0;
}

------------------------------------------
输出结果：
Set contains: 10 20 30 40 
20 is in the set.
After erasing 20, set contains: 10 30 40 
The set is not empty.
The set contains 3 elements.

stack

C++ 中，std::stack 容器是一种先进后出(First In Last Out, FILO)的数据结构，且只有一个出口。
在这里插入图片描述
push与emplace的异同点

对于int、double等内置数据类型而言，push()和emplace()是相同的
对于自定义数据类型而言，使用push()前必须先将要添加的对象构造出来(实例化)，而使用emplace()既可以填入实例化的对象也可以填入对象的构造参数。
push的功能emplace都包含。push传入的对象需要事先构造好，再复制过去插入容器中；而emplace则可以自己使用构造函数所需的参数构造出对象，并直接插入容器中。emplace相比于push省去了复制的步骤，则使用emplace会更加节省内存。

#include <iostream>
#include <stack>       //必须包含该头文件
using namespace std;

class ObjNumber
{
 public:
    string m_objName;
    int m_number; 
 public:
	ObjNumber(string name, int num)
	{
		m_objName = name;
		m_number = num;
	}
};

void test01()
{
	stack<ObjNumber> s1;
    ObjNumber obj1("茶叶", 1);  //实例化
	
    s1.push(obj1);    //push必须填入实例化的对象

    s1.emplace(obj1); //emplace既可以填入实例化的对象
	s1.emplace("馒头", 2);  //emplace也可以填入构造函数的参数

	cout << "s1中元素数量为：" << s1.size() << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

//result
s1中元素数量为：3

empty()	判断栈是否为空
size()	返回栈的大小
swap(stack<T> & other_stk)	将当前栈中元素和other_stk中元素交换
注意： swap()交换的两个栈中包含元素的类型必须相同。

#include <iostream>
#include <stack>       //必须包含该头文件
using namespace std;

void printStack(stack<int> &stk)
{
	while (!stk.empty())
	{
		cout << "当前栈顶元素：" << stk.top() << endl;

		stk.pop();   //弹出栈顶元素
	}
}

void test01()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);

	stack<int> s2(s1);    //拷贝

	cout << "s1中元素数量为：" << s1.size() << endl;
	cout << "s1中元素为：" << endl;
	printStack(s1);
	cout << "s2中元素数量为：" << s2.size() << endl;
	cout << "s2中元素为：" << endl;
	printStack(s2);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

//result
s1中元素数量为：3
s1中元素为：
当前栈顶元素：3
当前栈顶元素：2
当前栈顶元素：1
s2中元素数量为：3
s2中元素为：
当前栈顶元素：3
当前栈顶元素：2
当前栈顶元素：1

参考:https://blog.youkuaiyun.com/AAADiao/article/details/130850283

vector

emplace 关键字是 C++11 的一个新特性。emplace_back() 和 push_abck() 的区别是：push_back() 在向 vector 尾部添加一个元素时，首先会创建一个临时对象，然后再将这个临时对象移动或拷贝到 vector 中（如果是拷贝的话，事后会自动销毁先前创建的这个临时元素）；而 emplace_back() 在实现时，则是直接在 vector 尾部创建这个元素，省去了移动或者拷贝元素的过程。

假设 vector 中元素类型是类类型，那么 emplace_back() 待添加的元素的类型是类中有参构造的参数类型时，emplace_back() 比 push_back() 少一次移动或拷贝构造函数。而如果添加的元素是类类型的对象时，则和 push_back() 一样都只会调用一次移动构造函数或一次拷贝构造函数。

输出vector中所有元素的方法：
#include <iostream>
#include <vector>

using namespace std;

int main() {
    // 定义一个 vector 并初始化一些元素
    vector<int> nums = {1, 2, 3, 4, 5};

    // 方法1: 使用范围 for 循环
    cout << "Using range-based for loop: ";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;

    // 方法2: 使用标准 for 循环和下标访问
    cout << "Using index-based for loop: ";
    for (size_t i = 0; i < nums.size(); ++i) {
        cout << nums[i] << " ";
    }
    cout << endl;

    // 方法3: 使用迭代器
    cout << "Using iterator: ";
    for (vector<int>::iterator it = nums.begin(); it != nums.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

原文链接：https://blog.youkuaiyun.com/unonoi/article/details/114680819

参考：https://blog.youkuaiyun.com/unonoi/article/details/114680819

unordered_map

unordered_map是一个将key和value关联起来的容器，它可以高效的根据单个key值查找对应的value。
key值应该是唯一的，key和value的数据类型可以不相同。
unordered_map存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常高效，平均可以在常数时间内完成。
unordered_map查询单个key的时候效率比map高，但是要查询某一范围内的key值时比map效率低。
可以使用[]操作符来访问key值对应的value值。

std::unordered_map<std::string, std::int> umap; //定义

umap.insert(Map::value_type("test", 1));//增加

//根据key删除,如果没找到n=0
auto n = umap.erase("test")   //删除
 #erase()也不能直接删除

auto it = umap.find(key) //改
if(it != umap.end()) 
    it->second = new_value; 


//map中查找x是否存在
umap.find(x) != map.end()//查
//或者
umap.count(x) != 0

# 遍历map
unordered_map<key,T>::iterator it;
    (*it).first;   //the key value
    (*it).second   //the mapped value
    for(unordered_map<key,T>::iterator iter=mp.begin();iter!=mp.end();iter++)
          cout<<"key value is"<<iter->first<<" the mapped value is "<< iter->second;

    //也可以这样
    for(auto& v : mp)
        print v.first and v.second

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>

using namespace std;

int main() {
    // 示例输入
    vector<string> strs = {"eat", "tea", "tan", "ate", "nat", "bat"};

    // 定义用于分组的哈希表
    unordered_map<string, vector<string>> mp;

    // 遍历输入字符串
    // 遍历输入字符串
    for (string& str : strs) {
        // 对字符串排序，作为哈希表的键
        string key = str;
        sort(key.begin(), key.end());
        mp[key].emplace_back(str);

        // 输出哈希表的当前内容
        cout << "Current state of map:" << endl;
        for (const auto& pair : mp) {
            cout << "Key: " << pair.first << " -> Values: [ ";
            for (const auto& s : pair.second) {
                cout << s << " ";
            }
            cout << "]" << endl;
        }
        cout << endl;
    }

    // 输出结果
    vector<vector<string>> ans;
    for (auto it = mp.begin(); it != mp.end(); ++it) {
        ans.emplace_back(it->second);
    }

    // 打印结果
    for (const auto& group : ans) {
        cout << "[ ";
        for (const auto& word : group) {
            cout << word << " ";
        }
        cout << "]" << endl;
    }

    return 0;
}

--------------------------------------
pair.second 的使用
pair 是 unordered_map<string, vector<string>> 中的一个元素。它是一个 std::pair<const string, vector<string>> 类型的对象。
pair 是通过 range-based for loop（范围循环）直接从 mp 中解引用得到的，即它是 unordered_map 中的一个元素对象。
因为 pair 是一个实际的对象，您使用 . 操作符来访问它的成员 second，即 pair.second。
--------------------------------------
it 是 unordered_map<string, vector<string>>::iterator，即一个迭代器。
it 指向 unordered_map 容器中的一个元素，it 本质上是一个指针或类似指针的对象。
因为 it 是一个指针或指针类的对象，您使用 -> 操作符来访问指针指向的对象的成员 second，即 it->second。这相当于 (*it).second。