《C++ SYNTAX》第11章 算法

已于 2022-03-18 14:54:46 修改
阅读量143 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2022-01-05 10:51:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dasdkhaksd/article/details/122318226
版权

第11章 算法

(11.1) 函数对象

重载了函数调用操作符的类，其对象称为函数对象。特别地，函数对象使用重载的()时，由于其行为类似函数调用，因此也叫仿函数。

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

class MyAdd
{
public:
	int operator()(const int a,const int b)
	{
		return a + b;
	}
};

class MyPrint
{
public:
	int count; //记录调用次数
public:
	MyPrint()
	{
		this->count = 0;
	}
	void operator()(const string str)
	{
		cout << str << endl;
		this->count++;
	}
};

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

int main()
{
	MyAdd myAdd; //创建函数对象
	cout << myAdd(10, 20) << endl; //(1)函数对象可以像普通函数那样调用，可以有参数和返回值
	MyPrint myPrint;
	myPrint("Hello!");
	myPrint("Hello!");
	myPrint("Hello!");
	cout << "myPrint的调用次数为：" << myPrint.count << endl; //(2)函数对象可以有自己内部的状态(输出3)
	doPrint(myPrint,"Hello!"); //(3)函数对象可以作为参数进行传递
	system("pause");
	return 0;
}

返回bool类型的仿函数称为谓词。如果operator()接受一个参数，那么叫做一元谓词；如果operator()接受两个参数，那么叫做二元谓词。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class GT3 //一元谓词
{
public:
    bool operator()(const int a)
    {
        return a > 3;
    }
};

class MyCompare //二元谓词
{
public:
    bool operator()(const int a,const int b)
    {
        return a > b; //降序
    }
};

int main()
{
    vector<int> v;
    for (int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    //find_if算法第三个参数是谓词(即返回值为bool类型的仿函数)
    vector<int>::iterator it = find_if(v.begin(),v.end(),GT3()); //查找容器中大于3的数，返回迭代器
    if(it == v.end())
    {
        cout << "没有找到。" << endl;
    }
    else
    {
        cout << *it << endl; //4
    }
    sort(v.begin(),v.end()); //默认升序排列
    //sort算法的第三个参数也是谓词
    sort(v.begin(),v.end(),MyCompare());
    system("pause");
    return 0;
}

STL也提供了一些仿函数，这些仿函数被称为内建函数对象。有算术仿函数、关系仿函数、逻辑仿函数。需要包含头文件#include<functional>。

#include<iostream>
#include<functional> //使用内建函数对象需要包含这个头文件
using namespace std;
int main()
{
    //取相反数仿函数
    negate<int> n;
    cout << n(10) << endl; //-10
    //取余仿函数
    modulus<int> md;
    cout << md(13,5) << endl;; //3
    //加法仿函数
    plus<int> p;
    cout << p(10,20) << endl; //30
    //减法仿函数
    minus<int> m;
    cout << m(30,10) << endl; //20
    //乘法仿函数
    multiplies<int> ml;
    cout << ml(20,30) << endl; //600
    //除法仿函数
    divides<int> d;
    cout << d(100,10) << endl; //10
    system("pause");
    return 0;
}

#include<iostream>
#include<vector>
#include<functional>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    v.push_back(20);
    v.push_back(10);
    v.push_back(30);
    sort(v.begin(),v.end(),greater<int>()); //用STL提供的关系仿函数，实现降序排序
    //其他STL关系仿函数：
    //equal_to<T>(); //等于
    //not_equal_to<T>(); //不等于
    //greater<T>(); //大于
    //less<T>(); //小于
	//greater_equal<T>(); //大于等于
	//less_equal<T>(); //小于等于
    system("pause");
    return 0;
}

#include<iostream>
#include<vector>
#include<functional>
#include<algorithm>
using namespace std;
int main()
{
    vector<bool> v1;
    v1.push_back(true);
    v1.push_back(false);
    vector<bool> v2;
    v2.resize(v1.size());
    transform(v1.begin(),v1.end(),v2.begin(),logical_not<bool>()); //将v1搬运到v2中并取反
    //其他STL逻辑仿函数：
    //logical_and<T>(); //与
    //logical_or<T>(); //或
    //logical_not<T>(); //非
    system("pause");
    return 0;
}

(11.2) for_each

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void print(int a)
{
    cout << a << " ";
}

class Print
{
public:
    void operator()(int a)
    {
        cout << a << " ";
    }
};

int main()
{
    vector<int> v;
    for (int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    for_each(v.begin(),v.end(),print); //第三个参数是普通函数
    cout << endl;
    for_each(v.begin(),v.end(),Print()); //第三个参数是仿函数
    cout << endl;
    system("pause");
    return 0;
}

(11.3) transform

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class Transform
{
public:
    int operator()(int a)
    {
        return a; //啥也没做
    }
};

int main()
{
    vector<int> v1;
    for(int i = 0; i < 5; i++)
    {
        v1.push_back(i);
    }
    vector<int> v2;
    v2.resize(v1.size());
    transform(v1.begin(),v1.end(),v2.begin(),Transform()); //把v1搬运到v2里面去
    system("pause");
    return 0;
}

(11.4) find

查 找 内 置 数 据 类 型 查找内置数据类型 查找内置数据类型

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    for (int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    vector<int>::iterator pos = find(v.begin(),v.end(),5);
    if(pos == v.end())
    {
        cout << "没有找到。" << endl;
    }
    else
    {
        cout << *pos << endl;
    }
    system("pause");
    return 0;
}

查 找 自 定 义 数 据 类 型 查找自定义数据类型 查找自定义数据类型

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

class Person
{
public:
    string m_Name;
    int m_Age;
public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    bool operator==(const Person& p) //重载==，定义查找规则
    {
        if(this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

int main()
{
    vector<Person> v;
    Person p1("aaa",10);
    Person p2("bbb",20);
    Person p3("ccc",30);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    vector<Person>::iterator pos = find(v.begin(),v.end(),Person("aaa",10));
    if(pos == v.end())
    {
        cout << "没有找到。" << endl;
    }
    else
    {
        cout << "姓名：" << pos->m_Name << "年龄：" << pos->m_Age << endl;
    }
    system("pause");
    return 0;
}

(11.5) find_if

查 找 内 置 数 据 类 型 查找内置数据类型 查找内置数据类型

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class GT5
{
public:
    bool operator()(int a)
    {
        return a > 5;
    }
};

int main()
{
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    //find_if算法适合用来查找某个范围的元素
    vector<int>::iterator pos = find_if(v.begin(),v.end(),GT5()); //查找>5的数
    if (pos == v.end())
    {
        cout << "没有找到。" << endl;
    }
    else
    {
        cout << *pos << endl;
    }
    system("pause");
    return 0;
}

查 找 自 定 义 数 据 类 型 查找自定义数据类型 查找自定义数据类型

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

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

class AgeGT19
{
public:
    bool operator()(Person& p)
    {
        return p.m_Age > 19;
    }
};

int main()
{
    vector<Person> v;
    Person p1("aaa", 18);
    Person p2("bbb", 19);
    Person p3("ccc", 20);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    vector<Person>::iterator pos = find_if(v.begin(),v.end(),AgeGT19()); //查找年龄大于19的Person
    if(pos == v.end())
    {
        cout << "没有找到。" << endl;
    }
    else
    {
        cout << "姓名：" << pos->m_Name << "年龄：" << pos->m_Age << endl;
    }
    system("pause");
    return 0;
}

(11.6) adjacent_find

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    v.push_back(20);
    v.push_back(10);
    v.push_back(10);
    v.push_back(30);
    vector<int>::iterator pos = adjacent_find(v.begin(),v.end()); //查找相邻的重复元素
    if (pos == v.end())
    {
        cout << "没有找到有相邻的重复元素。" << endl;
    }
    else
    {
        cout << *pos << endl; //10
    }
    system("pause");
    return 0;
}

(11.7) binary_search

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    for(int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    bool searchRet = binary_search(v.begin(),v.end(),5); //二分查找是否有5(必须是有序序列)
    if (!searchRet)
    {
        cout << "容器中没有5。" << endl;
    }
    else
    {
        cout << "容器中有5。" << endl;
    }
    system("pause");
    return 0;
}

(11.8) count

统 计 内 置 数 据 类 型 统计内置数据类型 统计内置数据类型

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(10);
    v.push_back(30);
    int num = count(v.begin(),v.end(),10); //统计10的个数
    cout << "10的个数为：" << num << endl; //2
    system("pause");
    return 0;
}

统 计 自 定 义 数 据 类 型 统计自定义数据类型 统计自定义数据类型

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

class Person
{
public:
    string m_Name;
    int m_Age;
public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    /*
    这里必须要加const，底层是这样要求的，
    所以以后写重载的时候可以养成习惯统一都加const
    */
    bool operator==(const Person& p)
    {
        if(this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

int main()
{
    vector<Person> v;
    Person p1("张三",18);
    Person p2("李四",19);
    Person p3("王五",18);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    int num = count(v.begin(),v.end(),Person("孙七",18)); //统计和孙七同岁数的人
    cout << "和孙七同岁数的人有：" << num << endl; //2
    system("pause");
    return 0;
}

(11.9) count_if

统 计 内 置 数 据 类 型 统计内置数据类型 统计内置数据类型

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class GT20
{
public:
    bool operator()(const int a)
    {
        return a > 20;
    }
};

int main()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    //count_if算法一般是用来统计一个范围
    int num = count_if(v.begin(),v.end(),GT20()); //统计>20的元素个数
    cout << "大于20的元素个数为：" << num << endl;
    system("pause");
    return 0;
}

统 计 自 定 义 数 据 类 型 统计自定义数据类型 统计自定义数据类型

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

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

class AgeGT18
{
public:
    bool operator()(const Person& p)
    {
        return p.m_Age > 18;
    }
};

int main()
{
    vector<Person> v;
    Person p1("张三", 18);
    Person p2("李四", 19);
    Person p3("王五", 18);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    int num = count_if(v.begin(),v.end(),AgeGT18()); //统计年龄大于18的Person
    cout << "人数大于19的人数为：" << num << endl;
    system("pause");
    return 0;
}

(11.10) sort

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class MyCompare
{
public:
    bool operator()(const int a, const int b)
    {
        return a > b; //降序
    }
};

int main()
{
    vector<int> v;
    v.push_back(20);
    v.push_back(10);
    v.push_back(30);
    sort(v.begin(),v.end()); //默认升序
    sort(v.begin(),v.end(),MyCompare()); //传入仿函数改变排序策略
    system("pause");
    return 0;
}

(11.11) random_shuffle

#include<iostream>
#include<vector>
#include<algorithm>
#include<ctime>
using namespace std;
int main()
{
    srand((unsigned int)time(NULL));
    vector<int> v;
    for(int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    random_shuffle(v.begin(),v.end()); //随机洗牌
    system("pause");
    return 0;
}

(11.12) merge

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v1;
    vector<int> v2;
    for(int i = 0;i < 5;i++)
    {
        v1.push_back(i + 1);
        v2.push_back(i + 2);
    }
    vector<int> v;
    v.resize(v1.size() + v2.size()); //必须指定目标容器的大小
    merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v.begin()); //将v1和v2合并到v中(两个都必须有序)
    system("pause");
    return 0;
}

(11.13) reverse

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    reverse(v.begin(),v.end()); //将容器中元素反转
    system("pause");
    return 0;
}

(11.14) copy

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v1;
    for (int i = 0; i < 5; i++)
    {
        v1.push_back(i);
    }
    vector<int> v2;
    v2.resize(v1.size());
    copy(v1.begin(),v1.end(),v2.begin()); //将v1中的元素拷贝到v2中
    system("pause");
    return 0;
}

(11.15) replace

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v;
    for (int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    replace(v.begin(),v.end(),3,30); //将v中的3替换为30
    system("pause");
    return 0;
}

(11.16) replace_if

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class GT3
{
public:
    bool operator()(const int a)
    {
        return a > 3;
    }
};

int main()
{
    vector<int> v;
    for (int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    //replace_if算法适合用来替换某个范围的元素
    replace_if(v.begin(),v.end(),GT3(), 0); //将v中大于3的元素替换为0
    system("pause");
    return 0;
}

(11.17) swap

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    vector<int> v2;
    v2.push_back(30);
    swap(v1,v2); //将v1和v2的元素交换
    system("pause");
    return 0;
}

(11.18) accumulate

#include<iostream>
#include<vector>
#include<numeric> //需要添加算术生成算法头文件
using namespace std;
int main()
{
    vector<int> v;
    for(int i = 0;i < 5;i++)
    {
        v.push_back(i);
    }
    int total = accumulate(v.begin(),v.end(),0); //第三个参数是起始的累加值
    cout << "total = " << total << endl; //10
    system("pause");
    return 0;
}

(11.19) fill

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    vector<int> v;
    v.resize(10); //v有10个0
    fill(v.begin(),v.end(),10); //现在v有10个10
    system("pause");
    return 0;
}

(11.20) set_intersection

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void myPrint(int a)
{
    cout << a << " ";
}

int main()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 5; i++)
    {
        v1.push_back(i + 1); //1~5
        v2.push_back(i + 2); //2~6
    }
    vector<int> v;
    v.resize(min(v1.size(),v2.size())); //min也要包含algorithm头文件
    //求v1和v2的交集，返回的是结束迭代器
    vector<int>::iterator itEnd = set_intersection(v1.begin(),v1.end(),v2.begin(),v2.end(),v.begin());
    for_each(v.begin(),itEnd,myPrint); //2 3 4 5
    system("pause");
    return 0;
}

(11.21) set_union

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void myPrint(int a)
{
    cout << a << " ";
}

int main()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 5; i++)
    {
        v1.push_back(i + 1); //1~5
        v2.push_back(i + 2); //2~6
    }
    vector<int> v;
    v.resize(v1.size() + v2.size());
    //求v1和v2的并集，返回的是结束迭代器
    vector<int>::iterator itEnd = set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),v.begin());
    for_each(v.begin(),itEnd,myPrint); //1 2 3 4 5 6
    system("pause");
    return 0;
}

(11.22) set_difference

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void myPrint(int a)
{
    cout << a << " ";
}

int main()
{
    vector<int> v1;
    vector<int> v2;
    for (int i = 0;i < 5;i++)
    {
        v1.push_back(i + 1); //1~5
        v2.push_back(i + 2); //2~6
    }
    vector<int> v;
    v.resize(max(v1.size(),v2.size()));
    //求v1和v2的差集(在v1中，不在v2中)，返回的是结束迭代器
    vector<int>::iterator itEnd = set_difference(v1.begin(),v1.end(),v2.begin(),v2.end(),v.begin());
    for_each(v.begin(),itEnd,myPrint); //1
    system("pause");
    return 0;
}

《 C + +   S Y N T A X 》 系 列 博 客 创 作 参 考 资 料 来 源 《C++\ SYNTAX》系列博客创作参考资料来源 《C++ SYNTAX》系列博客创作参考资料来源

  1. 《黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难》@黑马程序员.https://www.bilibili.com.

博 客 创 作 ： A i d e n   L e e 博客创作：Aiden\ Lee 博客创作：Aiden Lee
特别声明：文章仅供学习参考，转载请注明出处，严禁盗用！

wibibaboo
关注
专栏目录
C++ 应用软件开发从入门到精通详解
dvlinker的技术专栏
06-21 3万+
本文详细介绍一下Windows平台下用C++开发应用软件的诸多内容，以供大家借鉴或参考。
C++ syntax
disizhangcu065587的博客
01-24 158
new: int *a = new int[size]; int **a = new int*[size]; 运算符重载： // 输入输出运算符必须被重载为全局函数！ class Complex { public: int a,b; }; Complex operator+(Complex &x, Complex &am...
《C++ SYNTAX》第3章 函数、指针、引用
Aiden Lee's blog
01-05 214
第3章 函数&指针&引用(3.1) 函数(3.2) 指针(3.3) 引用 (3.1) 函数 //无参无返函数 void func() { cout << "Hello！" << endl; } func(); //调用方法举例 //有参无返函数 void func(int a) { cout << "Hello！" << endl; } func(10); //调用方法举例 //无参有返函数 int func() {
C++语法汇总（上）
Aiden Lee's blog
01-05 244
另外，地址传递(只传递地址，占4或8个字节)相对于值传递(完全拷贝一份实参的数据给型参)会有更高的效率，这一点在结构体作为传递参数的时候更能充分体现。和地址传递一样，当有了引用传递后，如果我们不希望函数内部对传入的实参进行修改，这时候我们可以有意识地将函数的形参定义成。，传进函数的实参和函数中的形参的内存地址是不一样的，因此对形参的任何改变都不会影响到实参的值，下面这个。在C++中，函数的形参列表中的形参是可以有默认值的，这叫做函数的。：存放函数体的二进制代码，由操作系统进行管理，可共享和只读。
《C++ SYNTAX》第3章 数组
Aiden Lee's blog
01-05 275
第3章 数组(3.1) 一维数组(3.2) 二维数组(3.3) 数组常用算法 (3.1) 一维数组 C++的数组初始索引值为0；如果在初始化数据的时候没有全部填写，默认用0来填充。 int arr[5] = {1,2,3,4,5}; //数组长度和元素个数对应 int arr[] = {1,2,3,4,5}; //需要编译器自行推断数组的长度 #include<iostream> using namespace std; int main() { int arr[] = {1,2,
《C++ SYNTAX》第8章 多态
Aiden Lee's blog
01-05 219
第8章 多态(8.1) 多态概述(8.2) 虚函数和纯虚函数(8.3) 虚析构函数和纯虚析构函数(8.4) 多态的应用 (8.1) 多态概述 多态按字面的意思就是多种形态，即用相同的方法调用，但是有不同的实现方式，简单地概括为“一个接口，多种方法”。 静态多态：编译器根据函数实参的类型，可推断出要调用哪个函数，如果有对应的函数就调用该函数，否则出现编译错误，故也称为编译期间的多态(地址早绑定)。包括函数重载和函数模板。 动态多态：运行时的多态，在程序执行期间判断所引用对象的实际类型，根据其实际类型调用相应
【C++ Primer Plus】第14章 C++中的代码重用
chaiky的博客
10-19 1694
第14章 C++中的代码重用。has-a关系。 包含对象成员的类。 模板类valarray。 私有和保护继承。 多重继承。 虚基类。 创建类模板。 使用类模板。 模板的具体化。
c++ primer plus 第十四章 C++中的代码重用
weixin_59141600的博客
10-14 598
c++ 中的代码重用
Essential C++ Lippman 第1章 C++编程基础 摘录
weixin_47955824的博客
11-14 802
一些基础数据类型； 算术运算符； 条件分支和循环控制语句； 一些复合类型； 一套标准的、通用的抽象化库；
【C++ Primer】第一章 开始 (练习)
闻韶
08-05 774
C++ Primer 5th - 第一章 - 练习
C++及图像算法基础知识（二）
ChuanjieZhu
09-26 823
PS：为了面试准备的，总结的有点粗糙。   1.使用了未初始化的局部变量 错误：     正确：     2.指针与指向指针的指针 Pointer to an integer value int* i   Pointer to a pointer to an integer value int** i   3.i++ 与++i的区别 use ++i...
第19章 正则表达式 - C++
Venus_majian
12-05 583
正则表达式库提供表示正则表达式的类，正则表达式是一种用于在字符串中匹配模式的微型语言。目标序列。为模式而搜索到的字符序列。这可以是二个迭代器所指定的范围、空终止字符串或一个std::string。模式。这是正则表达式自身。它确定构成匹配者。它是从带特定语法的字符串构成的std::basic_regex 类型对象。匹配的数组。关于匹配的信息可作为std::match_results类型对象获取。替换字符串。这是确定如何替换匹配的字符串。
数据结构与算法Python语言实现《Data Structures & Algorithms in Python》手写课后答案--第七章
w__daxia的博客
07-26 1582
第七章 本章重点为灵活使用链表，深度理解位置链表 习题代码如下(部分代码引用书中源代码，源代码位置目录在第二章答案中介绍) # 本节默认队列使用书中源代码队列 # 单链表应该以None结尾,并未给出链表示列 # 简述：next为共有节点，可公共访问，first()返回头节点,没有保存尾节点 # 7.1 def text1(link): '''yield every node since after the second node from a link ''' node = lin
《C++ SYNTAX》第10章 容器
Aiden Lee's blog
01-05 691
第10章 容器(10.1) STL概述(10.2) string容器(10.3) vector容器(14.4) deque容器(14.5) stack容器(14.6) queue容器(14.7) list容器(14.8) set&multiset容器(14.9) map&multimap容器 (10.1) STL概述 长期以来，软件界一直希望建立一种可重复利用的东西，C++的面向对象和泛型编程思想，目的就是为了提高复用性。大多数情况下，数据结构和算法未能有一套标准，导致被迫从事大量重复的工
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1404
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 655
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 421
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 397
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
C++11标准：ISO/IEC 14882第三版
"ISO/IEC 14882 C++11标准是关于C++编程语言的第三版国际标准，发布于2011年9月1日。该标准详细定义了C++11版本的语言规范和技术特性，旨在提供信息技术领域的编程语言规范。" 在C++11这个标准中，包含了一系列重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值