05_泛型编程与STL之黑马程序员day05

于 2020-03-10 11:19:04 发布
阅读量148 收藏
点赞数
分类专栏： STL与泛型编程学习笔记_侯捷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40817333/article/details/104703048
版权

#2020/03/10
day01至day05完结

1.map容器

此处不再对函数具体介绍，可进入Cpp参考

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

//map容器初始化
void test01(){
    //map容器模板参数，第一个参数key的类型，第二参数value类型
    map<int, int> mymap;
 
    //插入数据  pair.first key值 piar.second value值
    //第一种
    pair<map<int, int>::iterator, bool> ret = mymap.insert(pair<int, int>(10, 10));           
    //iterator表示插入的位置
    if (ret.second){
        cout << "第一次插入成功!" << endl;
    }
    else{
        cout << "插入失败!" << endl;
    }
    ret = mymap.insert(pair<int, int>(10, 20));
    if (ret.second){
        cout << "第二次插入成功!" << endl;
    }
    else{
        cout << "插入失败!" << endl;
    }
    //第二种
    mymap.insert(make_pair(20, 20));
    //第三种
    mymap.insert(map<int, int>::value_type(30,30));
    //第四种
    mymap[40] = 40;
    mymap[10] = 20; 
    mymap[50] = 50;
    //发现如果key不存在，创建pair插入到map容器中
    //如果发现key存在，那么会修改key对应的value

    //打印
    for (map<int, int>::iterator it = mymap.begin(); it != mymap.end();it ++){
        // *it 取出来的是一个pair
        cout << "key:" << (*it).first << " value:" << it->second << endl;
    }
    
    //如果通过[]方式去访问map中一个不存在key，
    //那么map会将这个访问的key插入到map中,并且给value一个默认值
    cout << " mymap[60]: " <<  mymap[60] << endl;

    //打印
    for (map<int, int>::iterator it = mymap.begin(); it != mymap.end(); it++){
        // *it 取出来的是一个pair
        cout << "key:" << (*it).first << " value:" << it->second << endl;
    }
}

class MyKey{
public:
    MyKey(int index,int id){
        this->mIndex = index;
        this->mID = id;
    }
public:
    int mIndex;
    int mID;
};

struct mycompare{
    bool operator()(MyKey key1, MyKey key2){
        return key1.mIndex > key2.mIndex;
    }
};

void test02(){
    map<MyKey, int, mycompare> mymap; //自动排序，自定数据类型，咋排?
    
    mymap.insert(make_pair(MyKey(1, 2), 10));
    mymap.insert(make_pair(MyKey(4, 5), 20));

    for (map<MyKey, int, mycompare>::iterator it = mymap.begin(); it != mymap.end();it ++){
        cout << it->first.mIndex << ":" << it->first.mID << " = " << it->second << endl;
    }
}

//equal_range
void test03(){
    map<int, int> mymap;
    mymap.insert(make_pair(1, 4));
    mymap.insert(make_pair(2, 5));
    mymap.insert(make_pair(3, 6));

    pair<map<int, int>::iterator, map<int, int>::iterator> ret =  mymap.equal_range(2);
    if (ret.first != mymap.end()){
        cout << "找到lower_bound！" << endl;
    }
    else{
        cout << "没有找到";
    }

    if (ret.second != mymap.end()){
        cout << "找到upper_bound！" << endl;
    }
    else{
        cout << "没有找到";
    }
}

int main(void){
    //test01();
    //test02();
    test03();

    return 0;
}

2.multimap容器

multimap案例_员工分组

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <time.h>
#include <stdlib.h>
using namespace std;

#define SALE_DEPATMENT 1 //销售部门
#define DEVELOP_DEPATMENT 2 //研发部门
#define FINACIAL_DEPATMENT 3 //财务部门

//multimap 案例
//公司今天招聘了 5 个员工， 5 名员工进入公司之后，需要指派员工在那个部门工作
//人员信息有: 姓名 年龄 电话 工资等组成
//通过 Multimap 进行信息的插入 保存 显示
//分部门显示员工信息 显示全部员工信息

class Worker{
public:
    string mName;
    string mTele;
    int mAge;
    int mSalary;
};

void Create_Worker(vector<Worker>& vWorker){
    string seedName = "ABCDE";
    for (int i = 0; i < 5;i ++){
        Worker worker;
        worker.mName = "员工";
        worker.mName += seedName[i];

        worker.mAge = rand() % 10 + 20;
        worker.mTele = "010-8888888";
        worker.mSalary = rand() % 10000 + 10000;
        //保存员工信息
        vWorker.push_back(worker);
    }
}

//员工分组
void WorkerByGroup(vector<Worker>& vWorker, multimap<int, Worker>& workerGroup){
    //把员工随机分配不同部门
    srand(time(NULL));
    for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end();it ++){
        int departID = rand() % 3 + 1;
        switch (departID){
            case SALE_DEPATMENT:
                 workerGroup.insert(make_pair(SALE_DEPATMENT,*it));
                 break;
            case DEVELOP_DEPATMENT:
                 workerGroup.insert(make_pair(DEVELOP_DEPATMENT, *it));
                 break;
            case FINACIAL_DEPATMENT:
                 workerGroup.insert(make_pair(FINACIAL_DEPATMENT, *it));
                 break;
            default:
                 break;
        }
    }
}

void ShowGroupWorkers(multimap<int, Worker>& workerGroup, int departID){
    multimap<int, Worker>::iterator it = workerGroup.find(departID);
    //找当前部门总人数
    int DepartCount = workerGroup.count(departID);
    int num = 0;
    for (multimap<int, Worker>::iterator pos = it; it != workerGroup.end() && num <     
    DepartCount; pos++, num++){
        cout << "姓名:" << pos->second.mName << " 年龄:" << pos->second.mAge << " 电话:" <<    
        pos->second.mTele << " 工资:" << pos->second.mSalary << endl;
     }
}

//打印每一部分员工信息
void PrintWorkerByGroup(multimap<int, Worker>& workerGroup){
    //打印销售部员工信息

    //显示销售部门
    cout << "销售部门:" << endl;
    ShowGroupWorkers(workerGroup,SALE_DEPATMENT);
    //显示开发部门
    cout << "研发部门:" << endl;
    ShowGroupWorkers(workerGroup, DEVELOP_DEPATMENT);
    //显示财务部门
    cout << "财务部门:" << endl;
    ShowGroupWorkers(workerGroup, FINACIAL_DEPATMENT);
}

int main(void){
    //存放新员工的信息
    vector<Worker> vWorker;
    //multimap保存分组信息
    multimap<int, Worker> workerGroup;
    //创建员工
    Create_Worker(vWorker);
    //员工分组
    WorkerByGroup(vWorker, workerGroup);
    //打印每一部分员工信息
    PrintWorkerByGroup(workerGroup);

    return  0;
}

3.容器深拷贝和浅拷贝

深拷贝和浅拷贝的区别如下图所示：
在这里插入图片描述

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

class Person{
public:
    Person(char* name,int age){
        this->pName = new char[strlen(name) + 1];
        strcpy(this->pName, name);
        this->mAge = age;
    }
    Person(const Person& p){
        this->pName = new char[strlen(p.pName) + 1];
        strcpy(this->pName, p.pName);
        this->mAge = p.mAge;
    }
    Person& operator=(const Person& p){  // 该重载函数用于解决浅拷贝问题
        if (this->pName != NULL){
            delete[] this->pName;
        }
        this->pName = new char[strlen(p.pName) + 1];
        strcpy(this->pName, p.pName);
        this->mAge = p.mAge;

        return *this;
    }
    ~Person(){
        if (this->pName != NULL){
            delete[] this->pName;
         }
    }
public:
    char* pName; //指针 容易浅拷贝的问题
    int mAge;
};

void test01(){
    Person p("aaa",20);
    vector<Person> vPerson;
    vPerson.push_back(p);  //实际上p被拷贝进vector容器之中，浅复制会导致一次构造、两次析构
}

int main(void){
    test01();

    return 0;
}

4.函数对象

具体用法看test01()中的注释及下方代码示例：

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

struct MyPrint{   //函数对象(仿函数)
    MyPrint(){
        mNum = 0;
    }
    void operator()(int val){
        mNum++;
        cout << val << endl;
    }
public:
    int mNum;
};

int num = 0; //真正开发中，尽量避免去使用全局变量 加锁解锁
void MyPrint02(int val){
    num++;
    cout << val << endl;
}

void test01(){
    MyPrint print;
    print(10);
 
    //函数对象可以像普通函数一样调用
    //函数对象可以像普通函数那样接收参数
    //函数对象超出了函数的概念，函数对象可以保存函数调用的状态
}

void test02(){
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);

    //计算函数调用次数
#if 0
    MyPrint02(10);
    MyPrint02(20);
    cout << num << endl;
    
    MyPrint print;
    print(10);
    print(20);
    cout << print.mNum << endl;
#endif

    MyPrint print;
    MyPrint& print02 = for_each(v.begin(), v.end(), print);  // 原理可参考for_each()的定义

    cout << "print调用次数:" << print.mNum << endl;
    cout << "print调用次数:" << print02.mNum << endl;  //显示真正的调用次数
}

int main(void){
    test02();
    
    return 0;
}

5.内建函数对象

内建函数不需要自己定义，可以直接新建函数对象

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

void test01(){
    plus<int> myplus;
    cout << myplus(10, 20) << endl;
}

int main(void){
    test01();
    
    return 0;
}

6.函数对象适配器

具体见代码注释

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

//如果要适配，一定要继承binary_function<...>
struct MyPrint : public binary_function<int,int,void> {
// binary_function<int, int, void>中的void与operator()的返回类型相同
 // <int, int, void>的int, int与operator()(int, int)相同
    void operator()(int v,int val) const{
        cout << "v:" << v << " val:" << val << endl;
        cout << v + val << " ";
    }
};

//仿函数适配器 bind1st bind2nd 绑定适配器
void test01(){
    vector<int> v;
    for (int i = 0; i < 10;i ++){
        v.push_back(i);
    }
   
    int addNum = 200;
    for_each(v.begin(), v.end(), bind1st(MyPrint(), addNum));
    //绑定适配器  将一个二元函数对象转变成一元函数对象
    //bind1st bind2nd区别？
    //bind1st，将addNum绑定为函数对象的第一个参数
    //bind2nd，将addNum绑定为函数对象的第二个参数
}

struct MyPrint02{
    void operator()(int v){
        cout << v << " ";
    }
};

struct MyCompare : public binary_function<int,int,bool>{
    bool operator()(int v1, int v2) const{
        return v1 > v2;
    }
};

struct MyGreater5 : public binary_function<int,int,bool>{  //operator()(int)用unary_function<int, bool>
    bool operator()(int v,int val) const{
    cout << "v:" << v << " val:" << val << endl;
    return v < val;
    }
};

//仿函数适配器 not1 not2 取反适配器
void test02(){
    vector<int> v;
    for (int i = 0; i < 10; i++){
        v.push_back(i);
    }
    
    for_each(v.begin(), v.end(), MyPrint02()); cout << endl;
    sort(v.begin(), v.end(), not2(MyCompare()));
    for_each(v.begin(), v.end(), MyPrint02()); cout << endl;

    //not1 not2 
    //如果对二元谓词取反，用not2
    //如果对一元谓词取反，用not1
    vector<int>::iterator it = find_if(v.begin(), v.end(),not1(bind2nd(MyGreater5(),5)));
    if (it == v.end()){
        cout << "没有找到" << endl;
    }
    else{
        cout << *it << endl;
    }
}

//仿函数适配器 ptr_fun
void MyPrint03(int val,int val2){
    cout << "val1:" << val << " val2:" << val2 << endl;
    cout << val + val2 << endl;
}

void test03(){
    vector<int> v;
    for (int i = 0; i < 10; i++){
        v.push_back(i);
    }
    //ptr_func把普通函数 转成  函数对象
    for_each(v.begin(), v.end(), bind2nd(ptr_fun(MyPrint03),10));
}

//成员函数适配器 mem_fun mem_fun_ref
class Person{
public:
    Person(int age, int id) :age(age), id(id){}
    void show(){
        cout << "age:" << age << " id:" << id << " aaa" << endl;
    }
public:
    int age; 
    int id;
};
void test04(){
    //如果容器中存放的对象或者对象指针，我们for_each算法打印的时候，调用类
    //自己提供的打印函数，for_each()既可以接受普通函数也可以接受函数对象

    vector<Person> v;
    Person p1(10, 20), p2(30, 40), p3(50, 60);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);

    //格式: &类名::函数名
    for_each(v.begin(), v.end(), mem_fun_ref(&Person::show));

    vector<Person*> v1;
    v1.push_back(&p1);
    v1.push_back(&p2);
    v1.push_back(&p3);

    for_each(v1.begin(),v1.end(),mem_fun(&Person::show));

    //mem_fun_ref mem_fun区别?
    //如果存放的是对象指针 使用mem_fun
    //如果使用的是对象 使用mem_fun_ref
}

int main(void){
    //test01();
    //test02();
    //test03();
    test04();
    
    return 0;
}

7.常用的遍历算法

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

//transform 将一个容器的元素 搬运 到另一个容器中
struct MyPlus{
    int operator()(int val){
        return val + 100;
    }
};

void MyPrint(int val){
    cout << val << " ";
}
void test01(){
    vector<int> v1;
    vector<int> v2;

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

    v2.resize(v1.size()); //开辟空间

    //v1.begin()到v1.end()的值依次传给MyPlus()，MyPlus的返回值再传给v2
    transform(v1.begin(), v1.end(), v2.begin(), MyPlus());  
    for_each(v2.begin(), v2.end(), MyPrint);
    cout << endl;
}

//常用的查找算法
void test02(){
    vector<int> v1;
    for (int i = 0; i < 10; i++){
        v1.push_back(i);
    }
    
    vector<int>::iterator ret = find(v1.begin(), v1.end(), 5);
    if (ret == v1.end()){
        cout << "么有找到!" << endl;
    }
    else{
        cout << "找到了:" << *ret << endl;
    }
}

class Person{
public:
    Person(int age, int id) :age(age), id(id){}
    bool operator==(const Person& p) const{
        return p.id == this->id && p.age == this->age;
    }
public:
    int id;
    int age;
};

void test03(){
    vector<Person> v1;
    
    Person p1(10, 20), p2(20, 30);

    v1.push_back(p1);
    v1.push_back(p2);

    vector<Person>::iterator ret =  find(v1.begin(), v1.end(), p1);
    if (ret == v1.end()){
        cout << "么有找到!" << endl;
    }
    else{
        cout << "找到了:" << endl;
    }
}

//binary_search 二分查找法
bool MySearch(int val){
    return val > 5;
}
bool MySearch2(int val){
    return val > 5;
}
void test04(){
    vector<int> v1;
    for (int i = 0; i < 10; i++){
        v1.push_back(i);
    }
    v1.push_back(9);

    bool ret =binary_search(v1.begin(), v1.end(), 5);
    if (ret){
        cout << "找到！" << endl;
    }else{
        cout << "没有找到!" << endl;
    }

    vector<int>::iterator it =  adjacent_find(v1.begin(), v1.end());
    if (it != v1.end()){
        cout << "找到相邻重复元素:" << *it <<  endl;
    }
    else{
        cout << "没有找打相邻重复元素" << endl;
    }

    //find_if 会根据我们的条件(函数) ，返回第一个满足条件的元素的迭代器
    it =  find_if(v1.begin(), v1.end(), MySearch);
    if (it != v1.end()){
        cout << "找到:" << *it << endl;
    }
    else{
        cout << "没有找到" << endl;
    }
    
    //count count_if
    int num = count(v1.begin(), v1.end(), 9);
    cout << "9出现的次数:" << num << endl;
    num = count_if(v1.begin(), v1.end(), MySearch2);
    cout << "大于5的个数：" << num << endl;
}

int main(void){
    //test01();
    //test02();
    //test03();
    test04();

    return 0;
}
百事_可乐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cpp设计新思维_泛型编程与设计模式之应用
02-16
《Cpp设计新思维_泛型编程与设计模式之应用》这本书深入探讨了C++编程中的泛型编程和设计模式的应用，对于提升C++开发者的技术水平具有极高的价值。以下是本书涉及的一些关键知识点： 1. 泛型编程：泛型编程是C++中...
泛型编程与stl_11066337.rar
05-16
STL的设计原则就基于泛型编程，它允许用户使用自己的数据类型与STL组件配合。例如，我们可以通过自定义比较函数对象（仿函数）来改变`sort`算法的排序规则： ```cpp struct DescendingComparator { bool operator...
03_泛型编程与STL之黑马程序员day03
qq_40817333的博客
03-09 100
1.容器算法迭代器基本思路 2.STL_hello_world_程序 3.string容器 4.vector容器 5.Cpp输入输出流 6.文件读写
04_泛型编程与STL之黑马程序员day04
qq_40817333的博客
03-09 118
1.deque容器 2.stack容器 3.queue容器 4.list容器 5.set容器 6.对组
02_泛型编程与STL之黑马程序员day02
qq_40817333的博客
03-06 105
1.MyArray 2.类型转换 3.异常机制 4.栈解旋 5.异常接口声明 6.异常类型和异常对象生命周期 7.异常对象生命周期 8.Cpp标准异常库举例 9.继承在异常中的应用
01_泛型编程与STL之黑马程序员day01
qq_40817333的博客
02-23 169
模板的基本介绍 模板技术使类型参数化，在编写代码时可以忽略类型，避免编写类似重复的代码。 为了让编译器区分普通函数和模板函数：在模板函数的函数声明前添加template< class T> 或者 template< typename T>。 模板函数可以通过传入函数的参数来自动推导类型，也可以显式地指定类型。 #include <iostream> using ...
泛型编程与STL.pdf
02-13
网上找的，好多都会要积分，现在免费提供下载，C++进阶之必看经典
泛型编程与STL中文版
08-04
高清《泛型编程与STL中文版》。。。。。。。。。。。。。。。。。。。。
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
Android学习系列之gradle实战
07-23
Android学习系列之gradle实战
RFC 3261中文版技术文档
07-23
**标题与描述解析** 标题"RFC 3261 中文文档"指的是互联网请求评论（Request for Comments）3261的中文版本。RFC 3261是互联网工程任务组（IETF）发布的一个重要标准，它定义了SIP（Session Initiation Protocol，会话初始协议）的核心规范。SIP是一种用于建立、修改和终止多媒体通信会话的协议，广泛应用于VoIP（Voice over IP，IP语音）和统一通信系统中。 描述同样简洁明了，只强调了这是RFC 3261的中文翻译，意味着对于中文读者来说，这个文档提供了一个理解SIP协议的中文语言资源。 **标签解析** "RFC3261 中文"标签进一步确认了文档的内容，表明这是关于RFC 3261的中文资料，便于搜索和分类。 **压缩包子文件的文件名称列表** 文件名为"RFC3261 中文.mht"，这是一个单一网页文件，通常包含HTML、图像和其他资源，用于保存完整的网页内容。用户可以通过打开这个文件来查看RFC 3261的中文翻译。 **SIP协议详述** SIP协议是基于文本的，其设计类似于HTTP
嵌入式LinuxC语言程序设计基础教程第8章函数解读.doc
07-23
嵌入式
DirectShow滤镜：字幕叠加功能（含注解说明）
07-23
DirectShow Transform Filter最典型的例子，带注释，难度不大，学习必备 博客对应文章http://blog.csdn.net/leixiaohua1020/article/details/12498975。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
b069牙科就诊管理系统-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
牙科就诊管理系统利用当下成熟完善的SSM框架，使用跨平台的可开发大型商业网站的Java语言，以及最受欢迎的RDBMS应用软件之一的Mysql数据库进行程序开发。实现了用户在线查看数据。管理员管理病例管理、字典管理、公告管理、药单管理、药品管理、药品收藏管理、药品评价管理、药品订单管理、牙医管理、牙医收藏管理、牙医评价管理、牙医挂号管理、用户管理、管理员管理等功能。牙科就诊管理系统的开发根据操作人员需要设计的界面简洁美观，在功能模块布局上跟同类型网站保持一致，程序在实现基本要求功能时，也为数据信息面临的安全问题提供了一些实用的解决方案。可以说该程序在帮助管理者高效率地处理工作事务的同时，也实现了数据信息的整体化，规范化与自动化。 管理员在后台主要管理病例管理、字典管理、公告管理、药单管理、药品管理、药品收藏管理、药品评价管理、药品订单管理、牙医管理、牙医收藏管理、牙医评价管理、牙医挂号管理、用户管理、管理员管理等。 牙医列表页面，此页面提供给管理员的功能有：查看牙医、新增牙医、修改牙医、删除牙医等。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。药品管理页面，此页面提供给管理员的功能有：新增药品,修改药品,删除药品。药品类型管理页面，此页面提供给管理员的功能有：新增药品类型,修改药品类型,删除药品类型。
2014年4月-2023年11月上市公司ESG数据（秩鼎）（月度数据）.xlsx
07-23
2014年4月-2023年上市公司秩鼎ESG评级数据 1、时间：2014年4月-2023年11月 2、来源:秩鼎数据 3、指标：证券代码、SC、评级日期、ESG评级、ESG等级、ESG得分、E评级、E等级、E得分、S评级、S等级、S得分、G评级、G等级、G得分、总市值(亿元)、流通市值(亿元)、市盈率(TTM)、ESG标准正态、E标准正态、S标准正态、G标准正态、三者标准差、证券简称、 4、范围：上市公司
C++泛型编程与STL容器适配器详解
"这篇资料主要介绍了C++中的容器适配器和STL...STL通过模板和泛型编程提供了一套强大、高效且易于复用的工具，帮助C++程序员更便捷地实现复杂的数据结构和算法。学习和掌握STL能够显著提高C++编程的生产力和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值