wordpress批量增加用户/厦门seo网站推广

wordpress批量增加用户,厦门seo网站推广,泰州商城网站开发,上海广告公司官网设计模式23种 创建型抽象工厂模式工厂模式生成器模式原型模式单例模式 结构型适配器模式桥接模式组合模式装饰模式外观模式享元模式代理模式 行为型责任链模式命令模式解释器模式迭代器模式中介者模式备忘录模式观察者模式状态模式策略模式模版方法模式访问者模式 创建型 与对…

设计模式23种

  • 创建型
    • 抽象工厂模式
    • 工厂模式
    • 生成器模式
    • 原型模式
    • 单例模式
  • 结构型
    • 适配器模式
    • 桥接模式
    • 组合模式
    • 装饰模式
    • 外观模式
    • 享元模式
    • 代理模式
  • 行为型
    • 责任链模式
    • 命令模式
    • 解释器模式
    • 迭代器模式
    • 中介者模式
    • 备忘录模式
    • 观察者模式
    • 状态模式
    • 策略模式
    • 模版方法模式
    • 访问者模式

创建型

与对象的创建有关

抽象工厂模式

提供一个创建一系列相关或相互依赖的对象的接口

//来1张1费卡  1张2费卡 一系列相关
class Card {
public:virtual void out() = 0;
};
//还可以定义更多的卡牌
class CardCost1:public Card {
public:virtual void out() {cout << "我是1费卡" << endl;}
};class CardCost2 :public Card {
public:virtual void out() {cout << "我是2费卡" << endl;}
};class Factory {
public:virtual Card* CreateCost1() = 0;virtual Card* CreateCost2() = 0;
};
//还可以定义更多的工厂来组合
class CardFactory:public Factory {
public:Card* CreateCost1() {//来一张1费卡return new CardCost1();}Card* CreateCost2() {//来一张2费卡return new CardCost2();}
};
class CardFamaly
int main() {CardFactory *fac = new CardFactory();Card* cost1 = fac->CreateCost1();Card* cost2 = fac->CreateCost2();cost1->out();cost2->out();delete cost1;delete cost2;delete fac;return 0;
}

工厂模式

定义一个用于创建对象的接口,让子类决定实例化哪个类
//和抽象工厂区别是 1个和多个？

class Card {
public:virtual void out() = 0;
};class CardCost1:public Card {
public:virtual void out() {cout << "我是1费卡" << endl;}
};class CardCost2 :public Card {
public:virtual void out() {cout << "我是2费卡" << endl;}
};
class Factory {
public:virtual Card* Create() = 0;
};class CardCost1Factory:public Factory {
public:Card* Create() {return new CardCost1();}
};class CardCost2Factory :public Factory {
public:Card* Create() {return new CardCost2();}
};
int main() {CardCost1Factory* fac1 = new CardCost1Factory();CardCost2Factory* fac2 = new CardCost2Factory();Card* cost1 = fac1->Create();Card* cost2 = fac2->Create();cost1->out();cost2->out();delete cost1;delete cost2;delete fac1;delete fac2;return 0;
}

生成器模式

在某些情况下，一个对象的创建过程非常复杂，涉及多个步骤，每个步骤都可能有不同的实现方式。如果将所有创建逻辑放在一个类中，会导致该类变得庞大且难以维护。此外，如果需要创建不同的变体对象，就需要在该类中添加更多的逻辑，使得代码变得混乱。

原型模式

克隆

单例模式

就是单例

结构型

适配器模式

将一个类的接口转变为另外一个希望的接口

template<typename Type>
void permutation(Type first, int len) {int val = 1;for (int i = 0; i < len; i++) {*first = val;val++;first++;}
}int main() {vector<int> a;//本来vector 不能用 = int 赋值 ++//把vector =>back_insert_iterator(重载++ = ) 调用vector push_backpermutation(back_inserter(a), 10);int b[20];permutation(b, 10);return 0;
}

桥接模式

将抽象部分和其实现部分分离,使它们都可以独立的变化

//羁绊
class Jiban {
public:virtual void out() = 0;
};class Family :public Jiban {
public:virtual void out() {cout << " 家人 " << endl;}
};class ZhenMan :public Jiban {
public:virtual void out() {cout << " 铁血屈服者 " << endl;}
};
//英雄
class Hero {
public:virtual void out() = 0;virtual void SetJiban(Jiban* jb) = 0;Jiban* m_jb = nullptr;
};class BaoBao:public Hero {
public:virtual void out() {cout << " 爆爆 ";m_jb->out();}virtual void SetJiban(Jiban* jb) {m_jb = jb;}};class JieSi :public Hero {
public:virtual void out() {cout << " 杰斯 ";m_jb->out();}virtual void SetJiban(Jiban* jb) {m_jb = jb;}
};int main() {Family* family = new Family;ZhenMan* zm = new ZhenMan;JieSi* js = new JieSi();BaoBao* bb = new BaoBao();js->SetJiban(zm);bb->SetJiban(family);js->out();bb->out();return 0;}

组合模式

将对象组合成树型结构以表示整体与部分的层次结构
文件系统

装饰模式

动态的给一个对象添加一些额外的职责

class Water {
public:virtual int cost() = 0;virtual void out() = 0;
};class Wahaha :public Water {
public:virtual int cost() {return 2;}virtual void out() {cout << "娃哈哈";}
};class WaterDecorator :public Water {
public:WaterDecorator(Water* self) {m_self = self;}virtual int cost() {return m_self->cost();}virtual void out() {m_self->out();}Water* m_self;
};
//加冰
class IceDecorator :public WaterDecorator {
public:IceDecorator(Water* self) :WaterDecorator(self) {}virtual int cost() {return 1 + m_self->cost();}virtual void out() {m_self->out();cout << " 加冰 ";}
};
//加糖
class SugarDecorator :public WaterDecorator {
public:SugarDecorator(Water* self) :WaterDecorator(self) {}virtual int cost() {return 1 + m_self->cost();}virtual void out() {m_self->out();cout << " 加糖 ";}
};int main() {Wahaha* whh = new Wahaha();{IceDecorator* d = new IceDecorator(whh);SugarDecorator* d2 = new SugarDecorator(d);d2->out();cout << d2->cost() << endl;}return 0;
}

外观模式

为子系统中一组接口提供一个一致的界面

class Computer {
public:void turnOn() {cout << " 开电脑 ";}void turnOff() {cout << " 关电脑 ";}
};
class Light {
public:void turnOn() {cout << " 开灯 ";}void turnOff() {cout << " 关灯 ";}
};class MyLife {Computer computer;Light light;
public:void play() {computer.turnOn();light.turnOn();cout << endl;}void sleep() {computer.turnOff();light.turnOff();cout << endl;}
};int main() {MyLife* mf = new MyLife;mf->play();mf->sleep();return 0;
}

享元模式

运用共享技术有效的支持大量细粒度的对象

struct Base {
public:string name;int gongji;//攻击int fangyu;//防御
};class BaoBao{
public:BaoBao(Base *base) {m_base = base;x = y = 0;}Base* m_base;int x, y;//坐标
};class BaoBaoFactory {public:BaoBao* GetHero() {Base* base = nullptr;if (mmp.count("爆爆"))base = mmp["爆爆"];else {base = new Base;base->name = "爆爆";base->gongji = 999;base->fangyu = 999;mmp[base->name] = base;}return new BaoBao(base);}unordered_map<string, Base *> mmp;
};int main() {BaoBaoFactory* fac = new BaoBaoFactory();vector<BaoBao* > all;for (int i = 0; i < 100; i++) {all.push_back(fac->GetHero());}return 0;
}

代理模式

行为型

行为模式涉及算法和对象间职责的分配。行为模式不仅描述对象或类的模式，还描述它们之间的通信模式

责任链模式

使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递改请求，直到有一个对象处理它为止。

class Request {
public:Request(int m, string i) :money(m), info(i) {}int money;string info;
};class RequestHandler {
public:virtual void DoHandle(Request* req) = 0;void SetHandler(RequestHandler* handler) {m_handler = handler;}RequestHandler* m_handler = nullptr;
};class Father :public RequestHandler {
public:virtual void DoHandle(Request* req) {if (req->money <= 20) {cout << "Father Handler,give money = " << req->money << endl;}else if (m_handler) {req->money += 1000;m_handler->DoHandle(req);}}
};class Mother :public RequestHandler {
public:virtual void DoHandle(Request* req) {if (req->money <= 5000) {cout << "Mother Handler,give money = " << req->money << endl;}else if (m_handler) {m_handler->DoHandle(req);}}
};int main() {Request* r = new Request(500, "补课费");Father* f = new Father();Mother* m = new Mother();f->SetHandler(m);f->DoHandle(r);return 0;
}

命令模式

将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销操作。

class Light {
public:void TurnOn() {cout << "light TurnOn" << endl;}void TurnOff() {cout << "light TurnOff" << endl;}
};class Command {
public:virtual void exe() = 0;
};class OpenCommand :public Command {
public:void setLight(Light* light) {m_light = light;}virtual void exe() {m_light->TurnOn();}Light* m_light;
};class CloseCommand :public Command {
public:void setLight(Light* light) {m_light = light;}virtual void exe() {m_light->TurnOff();}Light* m_light;
};int main() {Light* light = new Light;OpenCommand* open = new OpenCommand;CloseCommand* close = new CloseCommand;open->setLight(light);close->setLight(light);open->exe();close->exe();return 0;
}

解释器模式

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

迭代器模式

提供一种顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。

中介者模式

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立的改变它们之间的交互。

class User;
class middleman {
public:virtual void sendMessage(string &msg, User* sender) = 0;virtual void addUser(User* user) = 0;
};class User {
public:User(string name, middleman* middleman):m_name(name),m_middleman(middleman){middleman->addUser(this);}void sendMessage(string &msg) {cout << m_name << ":Say " << msg << endl;m_middleman->sendMessage(msg,this);}void recvMessage(string& msg) {cout << m_name << ":Recv " << msg << endl;}string m_name;middleman* m_middleman;
};class ChatRoom :public middleman {vector<User*> m_all;
public:virtual void sendMessage(string &msg,User * sender) {for (auto user : m_all) {if (user == sender)continue;user->recvMessage(msg);}}virtual void addUser(User* user) {m_all.push_back(user);}
};int main() {ChatRoom* room = new ChatRoom();User* user1 = new User("小明", room);User* user2 = new User("小花", room);User* user3 = new User("康康", room);string msg = "How are you";user3->sendMessage(msg);return 0;
}

备忘录模式

在不破坏封装性的前提下捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可以将对象恢复原先保存的状态。

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
和中介者模式区别 1对多 和 多对多 树和图？

//观察者
class Observer {
public:virtual void update(int state) = 0;
};class ActObserver:public Observer {
public:ActObserver(string name, int state) :m_name(name), m_state(state) {}virtual void update(int state) {m_state = state;cout << m_name << ":update state = " << m_state << endl;}
private:string m_name;int m_state;
};//主题
class Subject {
public:virtual void addObserver(Observer *observer) = 0;virtual void removeObserver(Observer* observer) = 0;virtual void notify() = 0;
};class ActSubject {
public:virtual void addObserver(Observer* observer) {m_all.insert(observer);}virtual void removeObserver(Observer* observer) {m_all.erase(observer);}virtual void notify() {for (auto ob : m_all) {ob->update(m_state);}}
public:void setState(int state) { m_state = state;notify();}
private:set<Observer*> m_all;int m_state;
};int main() {ActObserver* aob = new ActObserver("小美", 0);ActObserver* aob2 = new ActObserver("小帅", 0);ActSubject* sub = new ActSubject();sub->addObserver(aob);sub->addObserver(aob2);sub->setState(2);sub->removeObserver(aob);sub->setState(1);return 0;
}

状态模式

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
把一堆if else 放到一个一个单独的类中处理

class State;
class Context {
public:virtual void SetState(State* state) = 0;
};class State {
public:virtual void handle(Context* context) = 0;Context *m_context = nullptr;
};class StateA :public State {
public:virtual void handle(Context* context) {cout << "StateA" << endl;//本来 if else 一坨 把每个状态拆在一个单独的类中处理 context->SetState(this);}
};class StateB :public State {
public:virtual void handle(Context* context) {cout << "StateB" << endl;context->SetState(this);}
};class ContextA :public Context {
public:ContextA() {m_state = new StateA();}virtual void SetState(State* state) {m_state = state;}void ChangeState(State* state) {state->handle(this);}State* m_state;
};int main() {StateA* A = new StateA();StateB* B = new StateB();ContextA* C = new ContextA();C->ChangeState(A);C->ChangeState(B);C->ChangeState(A);return 0;
}

策略模式

定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。此模式使得算法可以独立于使用它们的客户而变化。

class MathOperation {
public:virtual int DoOperation(int a, int b) = 0;
};
class Add :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a^2 + breturn a * a + b;}
};class Sub :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a - b^2return a - b * b;}
};class Calc {
public:void SetOperation(MathOperation* op) { m_op = op; }int DoIt(int a, int b) {return m_op->DoOperation(a, b);}
private:MathOperation* m_op;
};int main() {Add* add = new Add();Sub* sub = new Sub();Calc* calc = new Calc();calc->SetOperation(add);cout << "DoIt = " << calc->DoIt(1,2) << endl;calc->SetOperation(sub);cout << "DoIt = " << calc->DoIt(3, 4) << endl;return  0;
}

模版方法模式

定义一个操作中的算法骨架，而将一些步骤延迟到子类中。

class Hero {
public:virtual int getHurt() {//伤害计算算法return getPhysicsHurt() + getMagicHurt();}
public:virtual int getPhysicsHurt() = 0;//物理伤害virtual int getMagicHurt() = 0;//魔法伤害virtual string getName() = 0;};
//爆爆
class BaoBao:public Hero {
public:BaoBao(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 50;}virtual int getMagicHurt() {return 100;}virtual string getName() {return m_name;}string m_name;
};//杰斯 
class JieSi :public Hero {
public:JieSi(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 200;}virtual int getMagicHurt() {return 20;}virtual string getName() {return m_name;}string m_name;
};int main() {BaoBao* bb = new BaoBao("爆爆");JieSi* js = new JieSi("杰斯");cout << bb->getName() << " Hart = " << bb->getHurt() << endl;cout << js->getName() << " Hart = " << js->getHurt() << endl;return 0;
}

访问者模式

表示一个作用于某对象结构中的元素的操作。它允许在不改变各元素的类的前提下定义作用于这些元素的新操作。
英雄带装备

class Hero {
public:virtual int getPhysicsHurt() = 0;//物理伤害virtual int getMagicHurt() = 0;//魔法伤害virtual string getName() = 0;
};
//爆爆
class BaoBao:public Hero {
public:BaoBao(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 50;}virtual int getMagicHurt() {return 100;}virtual string getName() {return m_name;}string m_name;
};//杰斯 
class JieSi :public Hero {
public:JieSi(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 200;}virtual int getMagicHurt() {return 20;}virtual string getName() {return m_name;}string m_name;
};class Equipment {
public:virtual int getHurt(Hero* hero) = 0;
};
//帽子
class Maozi :public Equipment {
public:Maozi() {m_name = "帽子";dPhysicsRate = 1.1;dMagicRate = 2.0;}virtual int getHurt(Hero* hero) {int ans = hero->getPhysicsHurt()* dPhysicsRate + hero->getMagicHurt() * dMagicRate;cout << m_name << " " << hero->getName() << ":" << ans << endl;return ans;}
private:double dPhysicsRate;double dMagicRate;string m_name;
};int main() {BaoBao* bb = new BaoBao("爆爆");JieSi* js = new JieSi("杰斯");Maozi* mz = new Maozi();mz->getHurt(bb);mz->getHurt(js);return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/72456.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

目标在哪里？——寻找人生的意义与方向

目标在哪里？——寻找人生的意义与方向

在职场中&#xff0c;许多人都会经历这样的困惑&#xff1a;工作看似顺利&#xff0c;却逐渐失去了成就感和成长感。一位在500强企业工作的学员就遇到了这样的问题。她曾考虑过转型做培训&#xff0c;但苦于找不到明确的切入点&#xff0c;对未来的目标感到迷茫。她不禁问自己&…
阅读更多...
C++类与对象——拷贝构造与运算符重载

C++类与对象——拷贝构造与运算符重载

拷贝构造函数和赋值运算符重载就是C类默认六个函数之二。 拷贝构造函数&#xff1a; 如果⼀个构造函数的第⼀个参数是自身类类型的引用&#xff0c;且任何额外的参数都有默认值&#xff0c;则此构造函数 也叫做拷贝构造函数&#xff0c;也就是说拷贝构造是⼀个特殊的构造函数…
阅读更多...
Linux：进程程序替换

Linux：进程程序替换

目录 前言 一 进程程序替换的概念 二 进程程序替换的原理 三 为什么需要进行进程程序替换 四 如何进行进程程序替换 1. 进程替换函数 ➊ execl()函数 ➋execv()函数 ➌execlp()函数 ➍execle()函数 ➎execve()* 前言 一般情况下&#xff0c;对应的语言写的程序只…
阅读更多...
Umi-OCR 全家桶

Umi-OCR 全家桶

介绍&#xff1a; 下载 访问官网地址 https://github.com/hiroi-sora/umi-ocrhttps://github.com/hiroi-sora/umi-ocr 点击下载&#xff08;.exe 文件 安装即可&#xff09; 桌面使用 安装完毕后去安装路径下点击 Umi-OCR.exe &#xff08;默认不会生成桌面的快捷方式&…
阅读更多...
2023南京理工大学计算机复试上机真题

2023南京理工大学计算机复试上机真题

2023南京理工大学计算机复试上机真题 2023南京理工大学计算机复试机试真题 历年南京理工大学计算机复试上机真题 在线评测&#xff1a;传送门&#xff1a;pgcode.cn 括号匹配二 题目描述 苗苗今天刚刚学会使用括号&#xff0c;不过他分不清小括号&#xff0c;中括号&#…
阅读更多...
Axios简单说明，快速上手

Axios简单说明，快速上手

Ajax&#xff1a;异步的JavaScript和XML 作用&#xff1a; 数据交换异步交互 Axios&#xff1a;就是对原生Ajax进行封装&#xff0c;简化书写&#xff0c;快速开发 使用逻辑&#xff1a; 首先要安装Axios&#xff0c;可以通过npm在项目中安装&#xff1a; 打开命令行工具…
阅读更多...
模型评估——acc、P、R、F值、交叉验证、K折交叉验证

模型评估——acc、P、R、F值、交叉验证、K折交叉验证

模型评估&#xff1a;对预测函数地预测精度的评估。 多重回归&#xff1a;涉及三个及其以上的变量的回归问题。 评估模型的方法&#xff1a; 交叉验证&#xff1a;将数据集分成测试集和训练集&#xff0c;可以采用3&#xff1a;7或者2&#xff1a;8的比例方式进行划分&#xff…
阅读更多...
JVM 2015/3/15

JVM 2015/3/15

定义&#xff1a;Java Virtual Machine -java程序的运行环境&#xff08;java二进制字节码的运行环境&#xff09; 好处&#xff1a; 一次编写&#xff0c;到处运行 自动内存管理&#xff0c;垃圾回收 数组下标越界检测 多态 比较&#xff1a;jvm/jre/jdk 常见的JVM&…
阅读更多...
Compose 实践与探索九 —— DrawModifier 解析

Compose 实践与探索九 —— DrawModifier 解析

本篇讲解 DrawModifier 的基本用法与代码原理&#xff0c;介绍原理的目的在于可以判断绘制与绘制的关系&#xff0c;绘制与布局的关系。知道达成某种绘制效果应该怎么写&#xff0c;面对复杂的 Modifier 链时对效果有大致预判。 DrawModifier 管理绘制&#xff0c;需要以负责管…
阅读更多...
华为手机助手输入连接码时光标乱跳

华为手机助手输入连接码时光标乱跳

问题复现&#xff1a;输入12345678&#xff0c;光标自动跳转导致连接码出现乱序情况。 千万别试着找出规律&#xff0c;已试动态规律非大牛误轻试 问题原因&#xff1a; 想啥呢&#xff1f;华哥的软件又不是我开发我要Know Why干啥 我只需关心解决方案 &#xff08;可能时输入…
阅读更多...
Windows 11 安装Docker Desktop环境

Windows 11 安装Docker Desktop环境

1、确认CPU开启虚拟化 打开任务管理器&#xff0c;切换到“性能”选项卡&#xff0c;查看 CPU 信息。若“虚拟化”状态显示为“已启用”&#xff0c;则表示虚拟化已开启&#xff1b;若显示为“已禁用”&#xff0c;则需要在启动时进入 BIOS 开启虚拟化设置&#xff08;若显示已…
阅读更多...
STM32如何精准控制步进电机？

STM32如何精准控制步进电机？

在工业自动化、机器人控制等场合&#xff0c;步进电机以其高精度、开环控制的特性得到了广泛应用。而在嵌入式系统中&#xff0c;使用STM32进行步进电机的精确控制&#xff0c;已成为开发者的首选方案之一。 本文将从嵌入式开发者的角度&#xff0c;深入探讨如何基于STM32 MCU…
阅读更多...
【 ＜一＞ 炼丹初探：JavaWeb 的起源与基础】之 JavaWeb 项目的部署：从开发环境到生产环境

【 ＜一＞ 炼丹初探：JavaWeb 的起源与基础】之 JavaWeb 项目的部署：从开发环境到生产环境

<前文回顾> 点击此处查看 合集 https://blog.csdn.net/foyodesigner/category_12907601.html?fromshareblogcolumn&sharetypeblogcolumn&sharerId12907601&sharereferPC&sharesourceFoyoDesigner&sharefromfrom_link <今日更新> 一、开发环境…
阅读更多...
算法题（98）：大数加法

算法题（98）：大数加法

审题&#xff1a; 本题需要我们解决大数加法&#xff0c;大数直接运算会超出范围&#xff0c;所以我们需要转换成字符串一位位进行计算 思路&#xff1a; 方法一&#xff1a;高精度加法 我们将两个大数的每一个位分别计算&#xff0c;然后头插到answer字符串中即可 解题&#x…
阅读更多...
C# Exe + Web 自动化 （BitComet 绿灯 自动化配置、设置）

C# Exe + Web 自动化 （BitComet 绿灯 自动化配置、设置）

BitComet GreenLight,内网黄灯转绿灯 (HighID), 增加p2p连接率提速下载-CSDN博客 前两天写个这个&#xff0c;每次开机关机后要重来一遍很麻烦的索性写个自动化。 先还是按照上面的教程自己制作一遍&#xff0c;留下Luck 以及 路由器相关的 端口记录信息。 &#xff08;因为自…
阅读更多...
python---序列 (str，list，tuple)

python---序列 (str，list，tuple)

一、 序列类型入门 python的数据类型&#xff1a;int float bool str 运算符 - * / % > < and or not 流程控制ifelsewhilefor掌握python的2大容器类型数值类型&#xff08;3个&#xff09;&#xff1a;int float bool序列类型容器(3个)&#xff1a;str &#xff1a; …
阅读更多...
CSS元素层叠顺序规则

CSS元素层叠顺序规则

CSS元素层叠顺序规则 看图说话总结: background/borderz-index(<0)blockfloatinline/inline-blockz-index(0,auto)z-index (>0)
阅读更多...
ArcGIS Pro将有文字标注底图切换为无标注底图（在线地图图源）

ArcGIS Pro将有文字标注底图切换为无标注底图（在线地图图源）

今天介绍一下在ArcGIS Pro将有标注的地形底图换成无标注的底图。 大家在这项目底图时候会经常调用ArcGIS Pro自带的地形图&#xff0c;但是这个地形图自带是有注记的&#xff0c;如下图。 如何更改&#xff0c;才可以调用无文字注记的呢&#xff1f; 对于一个已经切好图的有注记…
阅读更多...
Xxl-Job学习笔记

Xxl-Job学习笔记

目录 概述 核心架构 核心特点 应用场景 什么是任务调度 快速入门 获取源码 初始化调度数据库 基本配置 数据源datasource 邮箱email&#xff08;可选&#xff09; 会话令牌access token 启动调度中心 启动执行器 依赖 yaml基本配置 XxlJobConfig类配置 定义执…
阅读更多...
让双向链表不在云里雾里

让双向链表不在云里雾里

又来博客留下我的足迹了&#xff0c;哈哈哈&#xff0c;这次是对于双向链表的理解 目录 创建双向链表&#xff1a; 申请结点&#xff1a; 双向链表初始化&#xff1a; 双向链表插入结点&#xff1a; 双向链表删除结点&#xff1a; 双向链表的打印&#xff1a; 双向链表…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023