ch9 模 板

最新推荐文章于 2024-09-22 21:28:15 发布
最新推荐文章于 2024-09-22 21:28:15 发布
阅读量210 收藏
点赞数
分类专栏： 学习笔记c++ c++练习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52065936/article/details/124469499
版权

一、冒泡排序函数模板

主程序测试整形数组、字符数组、字符串数组的排序（不使用STL）

//本程序实现从大到小排序
#include<iostream>
#include<string>
using namespace std;
template<typename T>
void BubbleSort(T a[], int n) {
	for (int i = 1; i < n; i++) {
		int temp = i;
		T tmp;
		for (int j = i - 1; j >= 0; j--) {
			if (a[temp] > a[j]) {
				tmp = a[temp];
				a[temp] = a[j];
				a[j] = tmp;
				temp = j;
			}
			else break;
		}
	}
}
int n;
int t;
int main() {
	cout << "请选择输入元素类型（1、整型，2、字符，3、字符串）：";
	cin >> t;
	cout << "请输入元素个数：";
	cin >> n;
	int *a = new int[n];
	char *b = new char[n];
	string *c = new string[n];
	cout << "请输入元素：";
	switch (t) {
	case 1:
		for (int i = 0; i < n; i++) {
			cin >> a[i];
		}
		BubbleSort(a, n);
		for (int i = 0; i < n; i++) {
			cout << a[i] << ' ';
		}
		break;
	case 2:
		for (int i = 0; i < n; i++) {
			cin >> b[i];
		}
		BubbleSort(b, n);
		for (int i = 0; i < n; i++) {
			cout << b[i] << ' ';
		}
		break;
	case 3:
		for (int i = 0; i < n; i++) {
			cin >> c[i];
		}
		BubbleSort(c, n);
		for (int i = 0; i < n; i++) {
			cout << c[i] << ' ';
		}
		break;
	}
	return 0;
}

二、类模板

Step1:设计一个通用的栈类（不使用STL），包含以下操作：

构造函数

析构函数

拷贝构造函数

判断是否为空

压栈操作

弹出操作

返回当前有几个元素

任意扩充栈大小的操作(resize)

重载赋值运算符

根据需要，设计其他操作

Step2:测试这个栈类模板

int 型栈

Double 栈

Char 栈

String 栈

Student 栈

说明：

栈是一种这样的数据结构：它像一个圆柱形的罐子，有底并且有一个开口。所以存放数据时，先放入的数据在下层，后放进的数据在上层；取出数据时，要按照顺序从上层开始取出。所以栈的操作特点是先进后出，后进先出。比如：把1、2、3放入栈，那么它们要按照3、2、1的顺序出栈；又比如：1、2、3保存在栈中，那么想取出2，操作步骤是：取出3、取出2、再放回3。在栈的操作中，“压栈”就是放入数据，“出栈”或“弹出”就是取出数据。

//Stack.h
#pragma once
#include"student.h"
#include<iostream>
using namespace std;

template <class E>
class Stack {   //顺序栈类定义
private:
    E* elements;			//栈元素存放数组
    int top;				//栈顶指针
    int maxSize;               		//栈最大容量
    void overflowProcess();	//栈的溢出处理
public:
    Stack(int sz = 50) {
        maxSize = sz;
        elements = new E[maxSize];
        top = -1;
    };		//构造函数
	Stack(const Stack<E>& s);         //拷贝构造函数
    ~Stack() { delete[]elements; }   //析构函数
    void Push(E x);	          		//进栈
    bool Pop(E& x);		//出栈
    bool getTop(E& x);		//取栈顶内容
    bool IsEmpty() const { return top == -1; }     //判断是否为空
    bool IsFull() const { return top == maxSize - 1; }    //判断是否为满
	int numOf() { return top+1; }    //返回当前几个元素
	void resize(int len);
	Stack<E>& operator=(Stack<E>& s) {
		top = s.top;
		maxSize = s.maxSize;
		elements = new E[maxSize];
		for (int i = 0; i <= top; i++) {
			elements[i] = s.elements[i];
		}
		return *this;
	}
};
template <class E>
Stack<E>::Stack(const Stack<E>& s) {
	maxSize = s.maxSize;
	top = s.top;
	elements = new E[maxSize];
	for (int i = 0; i <= top; i++) elements[i] = s.elements[i];
}
template <class E>
void Stack<E>::overflowProcess() {
	//私有函数：当栈满则执行扩充栈存储空间处理
	E* newArray = new E[2 * maxSize];				//创建更大的存储数组
	for (int i = 0; i <= top; i++)
		newArray[i] = elements[i];
	maxSize += maxSize;
	delete[]elements;
	elements = newArray;  	//改变elements指针
}

template <class E>
void Stack<E>::Push(E x) {
	//若栈不满, 则将元素x插入该栈栈顶, 否则溢出处理
	if (IsFull()) overflowProcess();	      //栈满
	elements[++top] = x;	     //栈顶指针先加1, 再进栈
}

template <class E>
bool Stack<E>::Pop(E& x) {
	//函数退出栈顶元素并返回栈顶元素的值
	if (IsEmpty()) return false;
	x = elements[top--];	     //栈顶指针退1
	return true;		     //退栈成功
}

template <class E>
bool Stack<E>::getTop(E& x) {
	//若栈不空则函数返回该栈栈顶元素的地址
	if (IsEmpty()) return false;
	x = elements[top];
	return true;
}
template<class E>
void Stack<E>::resize(int len) {
	if (len < top + 1) {
		cout << "the length is not enough!" << endl;
		return;
	}
	E* newArray = new E[len];
	for (int i = 0; i <= top; i++) {
		newArray[i] = elements[i];
	}
	maxSize = len;
	elements = newArray;
}
//student.h
#pragma once
#include"Stack.h"
#include<string>
using namespace std;
class Student {
public:
	Student(string s = "", double c = 0, double sc = 0) {
		name = s;
		credit = c;
		score = sc;
	}
	void setStudentName(string s = "", double c = 0, double sc = 0);
	void show();
	bool check(string);
private:
	string name;
	double credit;
	double score;
};
//student.cpp
#include"student.h"
#include<string>
#include<iostream>
#include<iomanip>
using namespace std;


void Student::setStudentName(string s, double c, double sc)
{
	name = s;
	credit = c;
	score = sc;
}

void Student::show()
{
	cout << "姓名：" << name << endl;
	cout << "学分：" << credit << endl;
	cout << "总成绩" << score << endl;
}

bool Student::check(string s)
{
	return name == s;
}
//main.cpp
#include"Stack.h"
#include"student.h"
#include<iostream>
#include<string>
using namespace std;
string sss[4] = { "asdf", "asfd", "adfsdf", "ffff" };
int main() {
	Stack<int> ints;
	Stack<char> chars;
	Stack<double> doubles;
	Stack<string> strings;
	Stack<class Student> students;
	cout << "Stack<int> test:" << endl;
	cout << "Is empty? " << ints.IsEmpty() << endl;
	cout << "Push ";
	for (int i = 1; i <= 10; i++) {
		ints.Push(i); cout << i << " ";
	}
	cout << "\nnumber of elements: " << ints.numOf() << endl;
	int x;
	
	
	cout << "Is full? " << ints.IsFull() << endl;
	cout << "resize 10" << endl;
	ints.resize(10);
	cout << "Is full? " << ints.IsFull() << endl;
	cout << "copy to Stack<int> stack2, pop stack2" << endl;
	Stack<int> ints1(ints);
	cout << "Pop(getTop) ";
	for (int i = 1; i <= 10; i++) {
		ints1.getTop(x);
		cout << x << " ";
		ints1.Pop(x);
	}
	cout << "\nStack<int> stack3 = stack1" << endl;
	Stack<int> ints2;
	ints2 = ints;
	cout << "pop: " << endl;
	for (int i = 1; i <= 10; i++) {
		ints2.Pop(x);
		cout << x << " ";
	}

	cout << endl;
	cout << "\nStack<double> test:" << endl;
	cout << "Is empty? " << doubles.IsEmpty() << endl;
	cout << "Push ";
	
	for (double i = 0.01; i <= 10; i++) {
		doubles.Push(i); cout << i << " ";
	}
	cout << "\nnumber of elements: " << doubles.numOf() << endl;
	double y;

	cout << "Is full? " << doubles.IsFull() << endl;
	cout << "resize 10" << endl;
	doubles.resize(10);
	cout << "Is full? " << doubles.IsFull() << endl;
	cout << "copy to Stack<double> stack2, pop stack2" << endl;
	Stack<double> doubles1(doubles);
	cout << "Pop(getTop) ";
	for (int i = 1; i <= 10; i++) {
		doubles1.getTop(y);
		cout << y << " ";
		doubles1.Pop(y);
	}
	cout << "\nStack<double> stack3 = stack1" << endl;
	Stack<double> doubles2;
	doubles2 = doubles;
	cout << "pop: " << endl;
	for (int i = 1; i <= 10; i++) {
		doubles2.Pop(y);
		cout << y << " ";
	}


	cout << endl;
	cout << "\nStack<string> test:" << endl;
	cout << "Is empty? " << strings.IsEmpty() << endl;
	cout << "Push ";
	for (int i = 0; i <= 3; i++) {
		strings.Push(sss[i]); cout << sss[i] << " ";
	}
	cout << "\nnumber of elements: " << strings.numOf() << endl;
	string z;

	cout << "Is full? " << strings.IsFull() << endl;
	cout << "resize 4" << endl;
	strings.resize(4);
	cout << "Is full? " << strings.IsFull() << endl;
	cout << "copy to Stack<string> stack2, pop stack2" << endl;
	Stack<string> strings1(strings);
	cout << "Pop(getTop) ";
	for (int i = 0; i <= 3; i++) {
		strings1.getTop(z);
		cout << z << " ";
		strings1.Pop(z);
	}
	cout << "\nStack<string> stack3 = stack1" << endl;
	Stack<string> strings2;
	strings2 = strings;
	cout << "pop: " << endl;
	for (int i = 0; i <= 3; i++) {
		strings2.Pop(z);
		cout << z << " ";
	}
	cout << endl;
	Student ss[4], aa;
	for (int i = 0; i <= 3; i++) {
		ss[i].setStudentName(sss[i], i + 10, i + 20);
		cout << "push student" << i + 1 << ": ";
		ss[i].show();
		cout << endl;
		students.Push(ss[i]);
	}
	for (int i = 0; i <= 3; i++) {
		students.Pop(aa);
		cout << "pop student:";
		aa.show();
		cout << endl;
	}
	return 0;
}

三、类模板

基于上面（题目二）设计的栈模板，设计实现一个简单的四则运算计算器，可以实现如下的操作：

例如：   1 + 2 * 3 – 4 / 2 #   答案：5

              2.5 * 5 + 7 / 2 – 1 #   答案：15

3 + 2 * ( 12 - 9 ) - 8 / 4 #

( 3 + 2 ) * 4 - 18 / ( 1 + 2 * 4 ) + 2 #

3 + 4 #

//Stack.h
#pragma once
#include"Stack.h"
#include<iostream>
using namespace std;

template <class E>
class Stack {   //顺序栈类定义
private:
    E* elements;			//栈元素存放数组
    int top;				//栈顶指针
    int maxSize;               		//栈最大容量
    void overflowProcess();	//栈的溢出处理
public:
    Stack(int sz = 50) {
        maxSize = sz;
        elements = new E[maxSize];
        top = -1;
    };		//构造函数
	Stack(const Stack<E>& s);         //拷贝构造函数
    ~Stack() { delete[]elements; }   //析构函数
    void Push(E x);	          		//进栈
    bool Pop(E& x);		//出栈
    bool getTop(E& x);		//取栈顶内容
    bool IsEmpty() const { return top == -1; }     //判断是否为空
    bool IsFull() const { return top == maxSize - 1; }    //判断是否为满
	int numOf() { return top+1; }    //返回当前几个元素
	void resize(int len);
	Stack<E>& operator=(Stack<E>& s) {
		top = s.top;
		maxSize = s.maxSize;
		elements = new E[maxSize];
		for (int i = 0; i <= top; i++) {
			elements[i] = s.elements[i];
		}
		return *this;
	}
};
template <class E>
Stack<E>::Stack(const Stack<E>& s) {
	maxSize = s.maxSize;
	top = s.top;
	elements = new E[maxSize];
	for (int i = 0; i <= top; i++) elements[i] = s.elements[i];
}
template <class E>
void Stack<E>::overflowProcess() {
	//私有函数：当栈满则执行扩充栈存储空间处理
	E* newArray = new E[2 * maxSize];				//创建更大的存储数组
	for (int i = 0; i <= top; i++)
		newArray[i] = elements[i];
	maxSize += maxSize;
	delete[]elements;
	elements = newArray;  	//改变elements指针
}

template <class E>
void Stack<E>::Push(E x) {
	//若栈不满, 则将元素x插入该栈栈顶, 否则溢出处理
	if (IsFull()) overflowProcess();	      //栈满
	elements[++top] = x;	     //栈顶指针先加1, 再进栈
}

template <class E>
bool Stack<E>::Pop(E& x) {
	//函数退出栈顶元素并返回栈顶元素的值
	if (IsEmpty()) return false;
	x = elements[top--];	     //栈顶指针退1
	return true;		     //退栈成功
}

template <class E>
bool Stack<E>::getTop(E& x) {
	//若栈不空则函数返回该栈栈顶元素的地址
	if (IsEmpty()) return false;
	x = elements[top];
	return true;
}
template<class E>
void Stack<E>::resize(int len) {
	if (len < top + 1) {
		cout << "the length is not enough!" << endl;
		return;
	}
	E* newArray = new E[len];
	for (int i = 0; i <= top; i++) {
		newArray[i] = elements[i];
	}
	maxSize = len;
	elements = newArray;
}
//main.cpp
#include"Stack.h"
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
bool analysis(string str) {
	for (int i = 0; i < str.length(); i++) {
		if (str[i] == '(' || str[i] == ')' || str[i] == '+' || str[i] == '-' || str[i] == '-' || str[i] == '*' || str[i] == '/') {
			continue;
		}
		else if (str[i] >= '0' && str[i] <= '9') {
			string tmp;
			while (str[i] >= '0' && str[i] <= '9') {
				tmp.push_back(str[i]);
				i++;
			}
			if (str[i] == '.') {
				i++;
				if (str[i] >= '0' && str[i] <= '9') {
					tmp.push_back('.');
					while (str[i] >= '0' && str[i] <= '9')
					{
						tmp.push_back(str[i]);
						i++;
					}
				}
				else {
					return false;
				}
			}
			i--;
		}
		else return false;
	}
	return true;
}
string preop(string s) {
	string n = "";
	for (int i = 0; i < s.length(); i++) {
		if (s[i] == ' ' || s[i] == '#') continue;
		n += s[i];
	}
	return n;
}
string format(string str) {    //部分负数补0
	for (int i = 0; i < str.length(); i++) {
		if (str[i] == '-') {
			if (i == 0) str.insert(0, 1, '0');
			else if (str[i - 1] == '(') {
				str.insert(i, 1, '0');
			}
		}
	}
	return str;
}
double readD(string str, int& m)
{
	int zh = 0;//整数部分
	int w = 1;//符号
	bool flag = false;//小数点
	double xi = 0.0;//小数部分
	double x = 1.0;//位
	int i = 1;
	char ch = str[0];//开读
	while (ch >= '0' && ch <= '9')//整数部分
	{
		zh = zh * 10 + ch - '0';
		ch = str[i++];
		m++;
	}
	while (ch < '0' || ch > '9')//找小数点
	{
		if (ch == '.') { flag = true; m++; }
		if (i >= str.length()) return zh;
		ch = str[i++];
	}
	if (!flag) return zh;//没有返回整数
	while (ch >= '0' && ch <= '9')//小数部分
	{
		x *= 10;
		xi = xi + (ch - '0') / x;
		ch = str[i++];
		m++;
	}
	if (w == 1) return zh + xi;
	else return zh - xi;
}
int priorisp(char x) {
	if (x == '#') return 0;
	if (x == '(') return 1;
	if (x == '^') return 7;
	if (x == '*' || x == '/') return 5;
	if (x == '+' || x == '-') return 3;
	if (x == ')') return 8;
	printf("OPTR error\n");
	return 0;
}
int prioricp(char x) {
	if (x == '#') return 0;
	if (x == '(') return 8;
	if (x == '^') return 6;
	if (x == '*' || x == '/') return 4;
	if (x == '+' || x == '-') return 2;
	if (x == ')') return 1;
	printf("OPTR error\n");
	return 0;
}
int main() {
	string s;
	getline(cin, s);
	s = preop(s);
	cout << s << '=';
	Stack<double> nums;
	Stack<char> ops;
	ops.Push('#');
	if (!analysis(s)) {
		cout << "error!(points, spaces...（初步判断不合法）)";
		return 0;
	}
	s = format(s) + '#';
	int idx = 0;
	while (idx < s.length()) {
		if (s[idx] >= '0' && s[idx] <= '9') {
			double n;
			int m = 0;
			n = readD(s.substr(idx, s.length()), m);
			nums.Push(n);
			idx += m;
			if (idx >= s.length()) break;
		}
		else if (s[idx] == '+' || s[idx] == '-' || s[idx] == '*' || s[idx] == '/' || s[idx] == '(' || s[idx] == ')' || s[idx] == '#')
		{
			char option = (char)s[idx];
			char oped, res;
			ops.getTop(oped);
			if (prioricp(option) > priorisp(oped)) {
				ops.Push(option);
				idx++;
			}
			else if (prioricp(option) < priorisp(oped)) {
				char a;
				if (ops.IsEmpty()) {
					cout << "Error!!!（缺少操作符）" << endl;
					return 0;
				}
				ops.Pop(a);
				double b;
				if (nums.IsEmpty()) {
					cout << "ERror!!（缺少操作数）" << endl;
					return 0;
				}
				nums.Pop(b);
				double c;
				if (nums.IsEmpty()) {
					cout << "ERRor!!!（缺少操作数）" << endl;
					return 0;
				}
				nums.Pop(c);
				if (a == '+') nums.Push(c + b);
				else if (a == '-') nums.Push(c - b);
				else if (a == '*') nums.Push(c * b);
				else if (a == '/') nums.Push(c / b);
			}
			else {
				ops.Pop(res);
				idx++;
			}
		}
		else 
		{
			idx++;
			continue;
		}
	}
	if (nums.IsEmpty()) {
		cout << "ERROR!!!（操作数栈为空）" << endl;
		return 0;
	}
	double ans;
	nums.Pop(ans);
	if (nums.IsEmpty()) {
		cout << ans << endl;
	}
	else cout << "ERROR！！！（操作数栈剩余两个数及以上）" << endl;
	return 0;
}

浅度断墨
关注
专栏目录
试着编写一个栈的类模板，至少包含构造函数、析构函数、压栈、出栈、取栈顶元素等成员函数，以便为任何类型的对象提供栈结构数据的操作，并在主函数中进行测试。
m0_51458138的博客
05-24 569
#include<iostream> #include<string> #include<cassert> using namespace std; template<typename T,int Size> class Stack { public: Stack(); ~Stack(); void Push(T e); int Top(); void Pop(); bool isFull()const; bool isEmpty()const.
微信公众号模板消息
json_li的博客
08-17 7155
目前项目中需要有一个除短信外其他方式通知或提醒用户业务操作的功能，故采用了微信的模板消息，把自己使用模板消息的过程和要点简要的记录一下。 一 、运营规则及使用规则 1.关于运营规则，注意： 解释一下：就是得与用户有交互的情况下，才能主动发给用户消息，而且消息得使用微信提供的模板，不能是营销类型的，也不能推送频率过大。最好使用前先看一下规则，是否跟自己的业务相符合。运营规则 模板消息仅用于公众号向用户发送重要的服务通知，只能用于符合其要求的服务场景中，如信用卡刷卡通知，商品购买成功通知等。不支持广
C++类模板实例化
热门推荐
jinzhu1911的专栏
09-04 1万+
C++类模板实例化 文章目录C++类模板实例化1. 简介2. 类模板实例化2.1 隐式实例化（Implicit instantiation）2.2 显示实例化（Explicit instantiation）2.3 类模板中的静态成员 1. 简介 该文章主要总结C++类模板实例化的方法。类模板的实例化包含两种： 隐式实例化（Implicit instantiation） 显示实例化（Explicit instantiation） 2. 类模板实例化 类模板本身不是类型、对象或任何其他实体。仅包含模板定义的
使用freemarker生成xml模板
猪哥
05-30 1万+
今天在java交流群里有个人问我如何用freemarker生成xml模板文件，可以手动配置参数，于是我到网上百度了一下。发现有一位同行的博文写的很nice，于是我就照着他的代码敲了一遍，最后实现了，本想贴出他的uri的，但是找不到了。网上这样的例子很多，大家可以自己到网上看看，我的建议是一个问题多看几个解决方案，这样才能找到正确的或者是最优解。 其实要实现的功能就是简单的将红框中的内容简
C++ 快读快输模板
weixin_44577381的博客
01-20 1万+
C++快读快输模板 【快读】 inline int read() { int X=0; char ch=getchar(); while(ch&amp;amp;amp;lt;'0'||ch&amp;amp;amp;gt;'9') ch=getchar(); while(ch&amp;amp;amp;gt;='0'&amp;amp;amp;amp;&amp;amp;amp;amp;ch&amp;amp;amp;lt;='9') {
模板
zyf2000
05-13 2303
while (!success()) try();
【模板整合】LCT模板
CreationAugust is 14 years old forever
08-16 2710
原题树的统计Count LCT动态维护树信息.比链剖好写但是速度真的没太有优势…#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #define LL long long #define MAXN 50010 #define MAXINT 0x7fffffff usin
蓝桥杯常用模板
weixin_51568657的博客
04-10 5491
文章目录蓝桥杯算法模板最大公约数（GCD）拓展欧几里得(EXGCD)最小公倍数（LCM）多个数的GCD和LCM判断闰年整数快速幂（用于快速求幂）快速幂取模快速乘(O(logn))对于一个大数最后结果只需要部分结尾数字，则在过程中取模即可逆元筛选素数01背包(每个物品只有一件)完全背包(每个物品有无数件)组合数模板前缀和与差分全排列函数next_permutation(arr,arr+n)全排列（递归）无重复元素有重复元素并查集迪杰斯特拉算法弗洛伊德算法BFSDFS合并区间平方数判断记忆化搜索二分查找 蓝桥杯
C++ | 矩阵类模板（类模板）
山风的小角落
06-22 9046
问题 B: 矩阵类模板（类模板）时间限制: 1 Sec  内存限制: 128 MB提交: 559  解决: 314[提交][状态][讨论版]题目描述设计一个矩阵类模板Matrix，支持任意数据类型的数据。要求至少包含2个成员函数：矩阵转置函数transport、以及打印输出函数print编写main函数进行测试，调用类的成员函数完成转置和输出。输入第一行先输入t，表示有t个测试用例从第二行开始输入...
模板的特化
m0_63852255的博客
09-08 2827
模板特化
CH7模板与STL1
08-03
第七章的讲解主要聚焦于C++中的模板与标准模板库（STL）这一主题，由张潇老师在机电与信息工程学院计算机系授课。模板是C++编程中一个至关重要的特性，它允许开发者创建泛型代码，即与特定数据类型无关的通用程序...
沁恒微电子CH32F20X工程模板
10-02
【沁恒微电子CH32F20X工程模板】是一个专为开发沁恒微电子CH32F20X系列单片机而设计的工程框架。这个模板为开发者提供了快速上手的基础环境，便于进行嵌入式系统的设计与调试工作。在了解这个模板之前，我们先来认识...
模板文档ch-lstm-forecast-mai笔记
08-16
模板文档ch-lstm-forecast-mai笔记
CH32V307多驱动模板包括AHT20,MPU6050,正交编码电机，CH9141蓝牙模块，TAU1201GPS,TFT屏幕
08-31
CH32V307多驱动模板 包括AHT20温湿度模块,mpu6050和icm20602六轴陀螺仪，imu600ra和imu963ra九轴陀螺仪,正交编码电机，CH9141蓝牙模块，tau1201GPS模块，IPS1.14和ST7735S屏幕，0.96OLED屏幕，CH573无线模块等 代码...
CH552工程模版.zip
08-07
CH552核心板PCB设计展示了如何将CH552芯片和其他外围元件合理布局在电路板上，确保信号传输的高效性和稳定性。设计者需要考虑的因素包括元件间的电气间距、电源和地线的布局、散热处理等。通过这份PCB设计，初学者...
【C++】 —— string的使用
LH__1314的博客
09-16 1492
string类虽然不在STL的容器中，但string类十分重要，string类是对字符串的存储和相关操作。
标准C++（二）
m0_63127040的博客
09-18 883
在C语言中定义的全局变量、函数、结构、联合、枚举、枚举值、宏都在全局作用域下，所以当项目比较庞大时，非常容易造成命名冲突（以模块名作前缀、后缀），所以C++中选择把全局作用域进行拆分成子作用域进行管理，这些子作用域就是作名字空间。把抽象结果（利用面向对象的思维模式，思考、观察出的结果），使用用C++的语法封装出一种类似结构的自定义数据类型（复合数据类型）。使用设计好的类（结构）这种数据类型，定义出的类变量在面向对象编程语言中被称为对象（结构变量），创建类对象的行为也被称为实例化对象。int id;
C++_map_set详解
2302_77644537的博客
09-16 1065
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C++ 解析 RDP 协议
最新发布
道亦无名
09-22 179
远程桌面协议（Remote Desktop Protocol, RDP）是微软开发的一种网络通信协议，用于提供远程桌面会话服务。它允许用户通过网络连接至远程计算机，并像使用本地计算机一样操作远程系统。本文档将详细探讨在C++环境中如何解析RDP协议，涵盖协议层次解析、连接过程管理、数据加密解密、功能数据处理、错误与异常处理以及协议版本适配等方面。
厦门大学C语言课件ch1-ch9及参考书概述
厦门大学C语言课件ch1-ch9是厦门大学C语言课程所使用的教材。该课件基于崔雅娟的《C语言-程序设计导论》和谭浩强的《C程序设计》(第四版)以及《C程序设计学习辅导》(第四版)。课件以教材为主，结合其他参考资料，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值