wordpress配置京东云/百度seo是啥

wordpress配置京东云,百度seo是啥,中铁三局招聘身材好,做网站用最新软件文章目录 一、C的struct和C的类的区别二、关于OOP三、举例：一个商品类CGoods四、构造函数和析构函数1、定义一个顺序栈2、用构造和析构代替s.init(5);和s.release();3、在不同内存区域构造对象4、深拷贝和浅拷贝5、构造函数和深拷贝的简单应用6、构造函数的初始化列…

文章目录

    • 一、C的struct和C++的类的区别
    • 二、关于OOP
    • 三、举例：一个商品类CGoods
    • 四、构造函数和析构函数
      • 1、定义一个顺序栈
      • 2、用构造和析构代替s.init(5);和s.release();
      • 3、在不同内存区域构造对象
      • 4、深拷贝和浅拷贝
      • 5、构造函数和深拷贝的简单应用
      • 6、构造函数的初始化列表
    • 五、类的各种成员变量和成员方法
      • 1、普通成员变量、静态成员变量
      • 2、普通成员方法、静态成员方法、常成员方法
    • 六、指向类成员（成员变量和成员方法）的指针

一、C的struct和C++的类的区别

以下表格由DeepSeek-R1生成：

特性C 的 structC++ 的 structC++ 的 class
默认访问权限无（仅数据）publicprivate
成员函数不支持支持支持
继承/多态不支持支持支持
构造/析构函数不支持支持支持
模板不支持支持支持
设计用途纯数据聚合简单数据+方法封装复杂对象行为

实际开发中，C++ 的 struct 和 class 仅默认权限不同，但习惯上用 struct 表示数据为主的结构，class 表示具有复杂行为的对象。

  • 在C中：
    各种各样的函数的定义、struct
  • 在C++中：
    实体(属性、行为)            ->            ADT(abstract data type)
    对象            <-(实例化)       类(属性->成员变量行为->成员方法)

二、关于OOP

  1. Object Oriented Programming：面向对象程序设计
  2. OOP语言的四大特性：抽象、封装/隐藏、继承、多态
  3. 类中的访问限定符：（由DeepSeek-R1生成）
基类成员访问限定符类内部访问继承方式派生类中基类成员的访问权限外部代码访问友元访问
public✔public 继承public✔✔
protected 继承protected✖✔
private 继承private✖✔
protected✔public 继承protected✖✔
protected 继承protected✖✔
private 继承private✖✔
private✔任何继承方式不可访问✖✔

三、举例：一个商品类CGoods

#include <iostream>
using namespace std;const int NAME_LEN = 20;class CGoods {
public: // 给外部提供公有的成员方法，来访问私有的属性// 商品数据初始化void init(const char *name, double price, int amount);// 打印商品信息void show();// 给成员变量提供getXXX或setXXX的方法（注意：类内部实现的方法，自动处理成inline内联函数）void setName(const char *name) { strcpy_s(_name, sizeof(_name), name); }void setPrice(double price) { _price = price; }void setAmount(int amount) { _amount = amount; }const char *getName() { return _name; }double getPrice() { return _price; }int getAmount() { return _amount; }
private:char _name[NAME_LEN];double _price;int _amount;
};void CGoods::init(const char *name, double price, int amount) {strcpy_s(_name, sizeof(_name), name);_price = price;_amount = amount;
}void CGoods::show() {cout << "name: " << _name << endl;cout << "price: " << _price << endl;cout << "amount: " << _amount << endl;
}int main() {CGoods good1;good1.init("面包", 10.0, 200); good1.show();good1.setPrice(20.5); good1.setAmount(100); good1.show();CGoods good2;good2.init("空调", 10000.0, 50);good2.show();return 0;
}

注意：

  1. 类可以定义无数个对象，每一个对象都有自己的成员变量，但是它们共享一套成员方法。
  2. 类内部实现的方法，自动处理成inline内联函数，外部则不会。
  3. 对象的内存大小，与成员变量有关。VS2022下可以通过cl C++面向对象.cpp /dlreportSingleClassLayoutCGoods查看占用内存大小。
  4. init(name，price，amount)怎么知道处理哪个对象的信息，把信息初始化给哪一个对象的呢?
    类的成员方法一经编译，所有的方法参数，都会加一个this指针，接收调用该方法的对象的地址。
	void init(CGoods *this, const char *name, double price, double amount);void CGoods::init(CGoods *this, const char *name, double price, int amount) {strcpy_s(this->_name, sizeof(this->_name), name);this->_price = price;this->_amount = amount;}init(&good1, "面包", 10.0, 200);

四、构造函数和析构函数

1、定义一个顺序栈

#include <iostream>
using namespace std;const int NAME_LEN = 20;class SeqStack {
public: void init(int size = 10) {_pstack = new int[size];_top = -1;_size = size;}void release() {delete[]_pstack;_pstack = nullptr;}void push(int val) {if (full()) {resize();}_pstack[++_top] = val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top == -1; }bool full() { return _top == _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp = new int[_size * 2];for (int i = 0; i < _size; ++i) {ptmp[i] = _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack = ptmp;_size *= 2;}
};int main() {SeqStack s;s.init(5); for (int i = 0; i < 15; ++i) {s.push(rand() % 100);}while (!s.empty()) {cout << s.top() << " ";s.pop();}s.release();return 0;
}

2、用构造和析构代替s.init(5);和s.release();

#include <iostream>
using namespace std;const int NAME_LEN = 20;class SeqStack {
public: SeqStack(int size = 10) { // 构造函数可带参数，可以重载_pstack = new int[size];_top = -1;_size = size;}~SeqStack() { // 不带参数，只能有一个delete[]_pstack;_pstack = nullptr;}void push(int val) {if (full()) {resize();}_pstack[++_top] = val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top == -1; }bool full() { return _top == _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp = new int[_size * 2];for (int i = 0; i < _size; ++i) {ptmp[i] = _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack = ptmp;_size *= 2;}
};int main() {//1.开辟内存 2.调用构造函数SeqStack s(5);//s.init(5); // 对象成员变量的初始化for (int i = 0; i < 15; ++i) {s.push(rand() % 100);}while (!s.empty()) {cout << s.top() << " ";s.pop();}//s.release(); // 释放对象成员变量占用的外部堆内存(外部资源)return 0;
}

3、在不同内存区域构造对象

#include <iostream>
using namespace std;const int NAME_LEN = 20;class SeqStack {
public: SeqStack(int size = 10) {cout << this << " SeqStack" << endl;_pstack = new int[size];_top = -1;_size = size;}~SeqStack() {cout << this << " ~SeqStack" << endl;delete[]_pstack;_pstack = nullptr;}void push(int val) {if (full()) {resize();}_pstack[++_top] = val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top == -1; }bool full() { return _top == _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp = new int[_size * 2];for (int i = 0; i < _size; ++i) {ptmp[i] = _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack = ptmp;_size *= 2;}
};/*
.data
heap
stack
*/
SeqStack s0; //.dataint main() {cout << "heap上对象构造" << endl;SeqStack* ps = new SeqStack(60); // heap malloc内存开辟+SeqStack对象构造ps->push(70);ps->push(80);ps->pop();cout << ps->top() << endl;delete ps; // 先调用ps->~SeqStack()+然后free(ps)cout << "stack上对象构造" << endl;SeqStack s(5); //stackfor (int i = 0; i < 15; ++i) {s.push(rand() % 100);}while (!s.empty()) {cout << s.top() << " ";s.pop();}cout << endl;return 0;
}

打印结果如下：

00007FF7FB3914C0 SeqStack
heap上对象构造
0000026D43E94EF0 SeqStack
70
0000026D43E94EF0 ~SeqStack
stack上对象构造
000000F8EF6FF9D8 SeqStack
61 27 81 45 5 64 62 58 78 24 69 0 34 67 41
000000F8EF6FF9D8 ~SeqStack
00007FF7FB3914C0 ~SeqStack

4、深拷贝和浅拷贝

	SeqStack s; // 没有提供任何构造函数的时候，会为你生成默认构造函数SeqStack s1(10);SeqStack s2 = s1; // #1 默认拷贝构造函数 -》做直接内存数据拷贝//Seqstack s3(s1);// #2 同1

在这里插入图片描述
上述默认构造函数导致出现浅拷贝的问题，浅拷贝一般包括以下几种问题：

  1. 多个对象共享同一资源：
    如果多个对象的指针成员指向同一块内存，修改其中一个对象会影响其他对象。

  2. 重复释放资源：
    当多个对象的指针指向同一块内存时，析构函数可能会多次释放同一块内存，导致程序崩溃。

  3. 内存泄漏：
    如果资源被浅拷贝后，原始对象的资源没有被正确释放，会导致内存泄漏。

默认拷贝构造函数：浅拷贝

	SeqStack(const SeqStack &src) {_pstack = src._pstack;_top = src._top;_size = src._size;}

深拷贝

	SeqStack(const SeqStack &src) {_pstack = new int[src._size];for (int i = 0; i <= src._top; ++i) {_pstack[i] = src._pstack[i];}_top = src._top;_size = src._size;}

如果对两个已经存在的对象进行赋值操作，也会出现浅拷贝问题

int main() {cout << "开始构造s" << endl;SeqStack s; // 没有提供任何构造函数的时候，会为你生成默认构造函数cout << "开始构造s1" << endl;SeqStack s1(10);cout << "开始构造s2" << endl;SeqStack s2 = s1; // #1 默认拷贝构造函数 -》做直接内存数据拷贝//Seqstack s3(s1);// #2 同1s2 = s1;return 0;
}

s2 = s1; // 默认的赋值函数 =》做直接的内存拷贝
修改如下：
// s2.operator=(s1)
// void operator=(const SeqStack &src)

#include <iostream>
using namespace std;const int NAME_LEN = 20;class SeqStack {
public: SeqStack(int size = 10) {cout << this << " SeqStack" << endl;_pstack = new int[size];_top = -1;_size = size;}// 自定义拷贝构造函数SeqStack(const SeqStack& src) { cout << this << " const SeqStack& src" << endl;_pstack = new int[src._size];for (int i = 0; i <= src._top; ++i) {_pstack[i] = src._pstack[i];}_top = src._top;_size = src._size;}// 赋值重载函数void operator=(const SeqStack& src) {cout << this << " operator=" << endl;// 防止自赋值if (this == &src) {return;}// 需要先释放当前对象占用的外部资源delete[]_pstack;_pstack = new int[src._size];for (int i = 0; i <= src._top; ++i) {_pstack[i] = src._pstack[i];}_top = src._top;_size = src._size;}~SeqStack() {cout << this << " ~SeqStack" << endl;delete[]_pstack;_pstack = nullptr;}void push(int val) {if (full()) {resize();}_pstack[++_top] = val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top == -1; }bool full() { return _top == _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp = new int[_size * 2];for (int i = 0; i < _size; ++i) {ptmp[i] = _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack = ptmp;_size *= 2;}
};int main() {cout << "开始构造s" << endl;SeqStack s; // 没有提供任何构造函数的时候，会为你生成默认构造函数cout << "开始构造s1" << endl;SeqStack s1(10);cout << "开始构造s2" << endl;SeqStack s2 = s1; // #1 默认拷贝构造函数 -》做直接内存数据拷贝//Seqstack s3(s1);// #2 同1s2 = s1;return 0;
}

打印结果：

开始构造s
0000003B8E14F6C8 SeqStack
开始构造s1
0000003B8E14F6F8 SeqStack
开始构造s2
0000003B8E14F728 const SeqStack& src
0000003B8E14F728 operator=
0000003B8E14F728 ~SeqStack
0000003B8E14F6F8 ~SeqStack
0000003B8E14F6C8 ~SeqStack

5、构造函数和深拷贝的简单应用

  1. 字符串String
#include <iostream>
using namespace std;class String {
public: String(const char* str = nullptr) { // 普通构造函数if (str != nullptr) {m_data = new char[strlen(str) + 1];strcpy_s(m_data, strlen(str) + 1, str);}else {m_data = new char[1];*m_data = '\0';}}String(const String& other) { // 拷贝构造函数m_data = new char[strlen(other.m_data) + 1];strcpy_s(m_data, strlen(other.m_data) + 1, other.m_data);}~String() {delete[]m_data;m_data = nullptr;}String& operator=(const String& other) { // 返回值不是void，而是当前类型的引用，是为了连续赋值if (this == &other) {return *this;}delete[]m_data;m_data = new char[strlen(other.m_data) + 1];strcpy_s(m_data, strlen(other.m_data) + 1, other.m_data);return *this;}private:char* m_data;
};int main() {// 调用带const char*参数的构造函数String str1;String str2("hello");String str3 = "world";// 调用拷贝构造函数String str4 = str3;String str5(str4);// 调用赋值重载函数str1 = str2;str3 = str1 = str2; // 连续赋值return 0;
}
  1. 循环队列Queue
#include <iostream>
using namespace std;class Queue {
public: Queue(int size = 20) {_pQue = new int[size];_front = _rear = 0;_size = size;}Queue(const Queue &src) {_front = src._front;_rear = src._rear;_size = src._size;_pQue = new int[_size];for (int i = _front; i != _rear; i = (i + 1) % _size) {_pQue[i] = src._pQue[i];}}Queue& operator=(const Queue& src) {if (this == &src) {return *this;}delete[]_pQue;_front = src._front;_rear = src._rear;_size = src._size;_pQue = new int[_size];for (int i = _front; i != _rear; i = (i + 1) % _size) {_pQue[i] = src._pQue[i];}return *this;}~Queue() {delete[]_pQue;_pQue = nullptr;}void push(int val) {// 入队操作if (full()) {resize();}_pQue[_rear] = val;_rear = (_rear + 1) % _size;}void pop() { // 出队操作if (empty()) {return;}_front = (_front + 1) % _size;}int front() {return _pQue[_front];}bool full() {return (_rear + 1) % _size == _front;}bool empty() {return _front == _rear;}private:int* _pQue; // 申请队列的数组空间int _front; // 指示队头的位置int _rear; // 指示队尾的位置int _size; // 队列扩容的总大小void resize() {int* ptmp = new int[2 * _size];int index = 0;for (int i = _front; i != _rear; i = (i + 1) % _size) {ptmp[index++] = _pQue[i];}delete[]_pQue;_pQue = ptmp;_front = 0;_rear = index;_size *= 2;}
};int main() {Queue q;for (int i = 0; i < 20; ++i) {q.push(rand() % 100);}while (!q.empty()) {cout << q.front() << " ";q.pop();}cout << endl;Queue q1 = q;q1 = q;return 0;
}

6、构造函数的初始化列表

#include <iostream>
using namespace std;class CDate {
public:CDate(int y, int m, int d) { //自定义的构造函数_year = y;_month = m;_day = d;}void show() {cout << _year << "/" << _month << "/" << _day << endl;}private:int _year;int _month;int _day; };/*
构造函数的初始化列表: 可以指定当前对象成员变量的初始化方式
CDate信息  CGoods商品信息的一部分  a part of ...  组合的关系
*/
class CGoods {
public: // "CDate"没有合适的构造函数可用，因此在这里使用初始化列表CGoods(const char *n, int a, double p, int y, int m, int d): _date(y, m, d), _amount(a) // 相当于int _amount = a;直接进行初始化，// 避免了先定义（int _amount; _amount = a;）需要调用默认构造函数，// 而CDate因为定义了自定义的构造函数，不会调用默认构造函数, _price(p)  // #1 构造函数的初始化列表{// #2 当前类类型构造函数体strcpy_s(_name, 20, n);}void show() {cout << "name: " << _name << endl;cout << "amount: " << _amount << endl;cout << "price: " << _price << endl;_date.show();}private:char _name[20];int _amount;double _price;CDate _date;    // 成员对象 1.分配内存 2.调用构造函数 
};int main() {CGoods good("商品", 100, 35.0, 2025, 1, 27);good.show();return 0;
}

注意：成员变量的初始化和它们定义的顺序有关，和构造函数初始化列表中出现的先后顺序无关!

#include <iostream>
using namespace std;class Test {
public: Test(int m = 10):mb(m), ma(mb) {}void show() {cout << "ma: " << ma << "mb: " << mb << endl;}private:int ma;int mb;
};int main() {Test t; t.show(); // ma: -858993460 mb: 10return 0;
}

Windows下会将未初始化的内存填充为特定的值0xCCCCCCCC（十进制为-858993460），先初始化ma，而此时mb未初始化，其值-858993460，因此ma: -858993460，而mb: 10。

五、类的各种成员变量和成员方法

1、普通成员变量、静态成员变量

2、普通成员方法、静态成员方法、常成员方法

  • 普通的成员方法 =>编译器会添加一个this形参变量
    1.属于类的作用域
    2.调用该方法时，需要依赖一个对象！常对象是无法调用的 实参:const CGoods* -》CGoods *this
    3.可以任意访问对象的私有成员 protected继承 public private
  • static静态成员方法 =>不会生成this形参
    1.属于类的作用域
    2.用类名作用域来调用方法
    3.可以任意访问对象的私有成员，仅限于不依赖对象的成员（只能调用其它的static静态成员）
  • const常成员方法 const CGoods *this
    1.属于类的作用域
    2.调用依赖一个对象，普通对象或者常对象都可以
    3.可以任意访问对象的私有成员，但是只能读，而不能写（只要是只读操作的成员方法，一律实现成const常成员方法）
#include <iostream>
using namespace std;const int NAME_LEN = 20;class CGoods {
public:CGoods(const char* name, double price, int amount);void show();void show() const;static void showCount();private:char _name[NAME_LEN];double _price;int _amount;static int _count; // 声明 用来记录商品对象的总数量；不属于对象，而属于类级别的
};// static成员变量一定要在类外进行定义并且初始化
int CGoods::_count = 0; CGoods::CGoods(const char* name, double price, int amount) {strcpy_s(_name, sizeof(_name), name);_price = price;_amount = amount;_count++; // 记录所有产生的新对象的数量
}// 普通成员方法 CGoods *this
void CGoods::show() {cout << "name: " << _name << endl;cout << "price: " << _price << endl;cout << "amount: " << _amount << endl;
}// 常成员方法 const CGoods *this
void CGoods::show() const {cout << "name: " << _name << endl;cout << "price: " << _price << endl;cout << "amount: " << _amount << endl;
}// 静态成员方法 没有this指针
void CGoods::showCount() {cout << "所有商品数量: " << _count << endl;
}int main() {CGoods good1("面包", 10.0, 200);good1.show();CGoods good2("空调", 100.0, 50);good2.show();CGoods::showCount();const CGoods good3("非卖品", 10000.0, 1);good3.show(); //CGoods::show(&good3) const CGoods* -> CGoods*不可以return 0;
}

六、指向类成员（成员变量和成员方法）的指针

指向普通成员变量的指针依赖于对象的调用，指向静态成员变量的指针不依赖。
指向普通成员方法的函数指针同样依赖于对象的调用，指向静态成员方法的指针不依赖。

#include <iostream>
using namespace std;class Test {
public:void func() { cout << "call Test::func" << endl; }static void static_func() { cout << "Test::static func" << endl; }int ma;static int mb;
};int Test::mb;int main() {Test t1; Test *t2 = new Test();// 指向成员变量的指针// int a=10; int *p=&a; *p=30;int Test::*p = &Test::ma;t1.*p = 20;cout << t1.*p<< endl;t2->*p = 30; cout << t2->*p << endl; // 指向静态成员变量的指针int *p1 = &Test::mb;*p1 = 40;cout << *p1 << endl;// 指向成员方法的指针void (Test::*pfunc)() = &Test::func; (t1.*pfunc)();(t2->*pfunc)();// 定义函数指针指向类的静态成员方法void(*pfunc1)() = &Test::static_func;(*pfunc1)();delete t2;return 0;
}

打印结果如下：

20
30
40
call Test::func
call Test::func
Test::static func

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

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

相关文章

Excel 技巧21 - Excel中整理美化数据实例，Ctrl+T 超级表格(★★★）

Excel 技巧21 - Excel中整理美化数据实例，Ctrl+T 超级表格(★★★）

本文讲Excel中如何整理美化数据的实例&#xff0c;以及CtrlT 超级表格的常用功能。 目录 1&#xff0c;Excel中整理美化数据 1-1&#xff0c;设置间隔行颜色 1-2&#xff0c;给总销量列设置数据条 1-3&#xff0c;根据总销量设置排序 1-4&#xff0c;加一个销售趋势列 2&…
阅读更多...
Leetcode 131 分割回文串(纯DFS)

Leetcode 131 分割回文串(纯DFS)

131. 分割回文串https://leetcode.cn/problems/palindrome-partitioning/https://leetcode.cn/problems/palindrome-partitioning/ 给你一个字符串 s&#xff0c;请你将 s 分割成一些子串&#xff0c;使每个子串都是 回文串 。返回 s 所有可能的分割方案。 示例 1&#xff1a…
阅读更多...
关于安卓greendao打包时报错问题修复

关于安卓greendao打包时报错问题修复

背景 项目在使用greendao的时候&#xff0c;debug安装没有问题&#xff0c;一到打包签名就报了。 环境 win10 jdk17 gradle8 项目依赖情况 博主的greendao是一个独立的module项目&#xff0c;项目目前只适配了java&#xff0c;不支持Kotlin。然后被外部集成。greendao版本…
阅读更多...
一文讲解Java中的BIO、NIO、AIO之间的区别

一文讲解Java中的BIO、NIO、AIO之间的区别

BIO、NIO、AIO是Java中常见的三种IO模型 BIO&#xff1a;采用阻塞式I/O模型&#xff0c;线程在执行I/O操作时被阻塞&#xff0c;无法处理其他任务&#xff0c;适用于连接数比较少的场景&#xff1b;NIO&#xff1a;采用非阻塞 I/O 模型&#xff0c;线程在等待 I/O 时可执行其…
阅读更多...
分布式系统架构怎么搭建？

分布式系统架构怎么搭建？

分布式系统架构 互联网企业的业务飞速发展&#xff0c;促使系统架构不断变化。总体来说&#xff0c;系统架构大致经历了单体应用架构—垂直应用架构—分布式架构—SOA架构—微服务架构的演变&#xff0c;很多互联网企业的系统架构已经向服务化网格&#xff08;Service Mesh&am…
阅读更多...
数据库备份、主从、集群等配置

数据库备份、主从、集群等配置

数据库备份、主从、集群等配置 1 MySQL1.1 docker安装MySQL1.2 主从复制1.2.1 主节点配置1.2.2 从节点配置1.2.3 创建用于主从同步的用户1.2.4 开启主从同步1.2.4 主从同步验证 1.3 主从切换1.3.1 主节点设置只读&#xff08;在192.168.1.151上操作&#xff09;1.3.2 检查主从数…
阅读更多...
代码随想录_栈与队列

代码随想录_栈与队列

栈与队列 232.用栈实现队列 232. 用栈实现队列 使用栈实现队列的下列操作&#xff1a; push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 思路: 定义两个栈: 入队栈, 出队栈, 控制出入…
阅读更多...
AJAX综合案例——图书管理

AJAX综合案例——图书管理

黑马程序员视频地址&#xff1a; AJAX-Day02-10.案例_图书管理AJAX-Day02-10.案例_图书管理_总结_V1.0是黑马程序员前端AJAX入门到实战全套教程&#xff0c;包含学前端框架必会的&#xff08;ajaxnode.jswebpackgit&#xff09;&#xff0c;一套全覆盖的第25集视频&#xff0c…
阅读更多...
【编译原理实验二】——自动机实验：NFA转DFA并最小化

【编译原理实验二】——自动机实验：NFA转DFA并最小化

本篇适用于ZZU的编译原理课程实验二——自动机实验&#xff1a;NFA转DFA并最小化&#xff0c;包含了实验代码和实验报告的内容&#xff0c;读者可根据需要参考完成自己的程序设计。 如果是ZZU的学弟学妹看到这篇&#xff0c;那么恭喜你&#xff0c;你来对地方啦&#xff01; 如…
阅读更多...
【redis进阶】分布式锁

【redis进阶】分布式锁

目录 一、什么是分布式锁 二、分布式锁的基础实现 三、引入过期时间 四、引入校验 id 五、引入lua 六、引入 watch dog (看门狗) 七、引入 Redlock 算法 八、其他功能 redis学习&#x1f973; 一、什么是分布式锁 在一个分布式的系统中&#xff0c;也会涉及到多个节点访问同一…
阅读更多...
Blazor-@bind

Blazor-@bind

数据绑定 带有 value属性的标记都可以使用bind 绑定&#xff0c;<div>、<span>等非输入标记&#xff0c;无法使用bind 指令的&#xff0c;默认绑定了 onchange 事件&#xff0c;onchange 事件是指在输入框中输入内容之后&#xff0c;当失去焦点时执行。 page &qu…
阅读更多...
洛谷P3383 【模板】线性筛素数

洛谷P3383 【模板】线性筛素数

题目链接&#xff1a;P3383 【模板】线性筛素数 - 洛谷 | 计算机科学教育新生态 题目难度&#xff1a;普及一 题目分析&#xff1a;本题是模板题&#xff0c;用到了线性筛法&#xff0c;其中原理是保证范围内的每个合数都被删掉&#xff08;在 bool 数组里面标记为非素数…
阅读更多...
STM32标准库移植RT-Thread nano

STM32标准库移植RT-Thread nano

STM32标准库移植RT-Thread Nano 哔哩哔哩教程链接&#xff1a;STM32F1标准库移植RT_Thread Nano 移植前的准备 stm32标准库的裸机代码&#xff08;最好带有点灯和串口&#xff09;RT-Thread Nano Pack自己的开发板 移植前的说明 本人是在读学生&#xff0c;正在学习阶段&a…
阅读更多...
JVM--类加载器

JVM--类加载器

概念 类加载器&#xff1a;只参与加载过程中的字节码获取并加载到内存中的部分&#xff1b;java虚拟机提供给应用程序去实现获取类和接口字节码数据的一种技术&#xff0c;也就是说java虚拟机是允许程序员写代码去获取字节码信息 类加载是加载的第一步&#xff0c;主要有以下三…
阅读更多...
ECMAScript 6语法

ECMAScript 6语法

1.ES6简介 ECMAScript 6&#xff08;简称ES6&#xff09;是于2015年6月正式发布的JavaScript语言的标准&#xff0c;正式名为ECMAScript 2015&#xff08;ES2015&#xff09;。它的目标是使得JavaScript语言可以用来编写复杂的大型应用程序&#xff0c;成为企业级开发语言 。 …
阅读更多...
联想Y7000+RTX4060+i7+Ubuntu22.04运行DeepSeek开源多模态大模型Janus-Pro-1B+本地部署

联想Y7000+RTX4060+i7+Ubuntu22.04运行DeepSeek开源多模态大模型Janus-Pro-1B+本地部署

直接上手搓了&#xff1a; conda create -n myenv python3.10 -ygit clone https://github.com/deepseek-ai/Janus.gitcd Januspip install -e .pip install webencodings beautifulsoup4 tinycss2pip install -e .[gradio]pip install pexpect>4.3python demo/app_januspr…
阅读更多...
FastAPI + GraphQL + SQLAlchemy 实现博客系统

FastAPI + GraphQL + SQLAlchemy 实现博客系统

本文将详细介绍如何使用 FastAPI、GraphQL&#xff08;Strawberry&#xff09;和 SQLAlchemy 实现一个带有认证功能的博客系统。 技术栈 FastAPI&#xff1a;高性能的 Python Web 框架Strawberry&#xff1a;Python GraphQL 库SQLAlchemy&#xff1a;Python ORM 框架JWT&…
阅读更多...
微服务入门（go）

微服务入门（go）

微服务入门&#xff08;go&#xff09; 和单体服务对比&#xff1a;里面的服务仅仅用于某个特定的业务 一、领域驱动设计&#xff08;DDD&#xff09; 基本概念 领域和子域 领域&#xff1a;有范围的界限&#xff08;边界&#xff09; 子域&#xff1a;划分的小范围 核心域…
阅读更多...
【B站保姆级视频教程：Jetson配置YOLOv11环境（二）SSH连接的三种方式】

【B站保姆级视频教程：Jetson配置YOLOv11环境（二）SSH连接的三种方式】

B站同步视频教程&#xff1a;https://www.bilibili.com/video/BV1m5wUeyEQD/ 在Jetson设备上配置YOLOv11环境时&#xff0c;SSH连接是实现远程高效开发与管理的关键一环。不同的网络环境和硬件配置可能会影响SSH连接的方式&#xff0c;本文将结合相关视频内容&#xff0c;详细…
阅读更多...
计算机毕业设计Python+知识图谱大模型AI医疗问答系统 健康膳食推荐系统 食谱推荐系统 医疗大数据 机器学习 深度学习 人工智能 爬虫 大数据毕业设计

计算机毕业设计Python+知识图谱大模型AI医疗问答系统 健康膳食推荐系统 食谱推荐系统 医疗大数据 机器学习 深度学习 人工智能 爬虫 大数据毕业设计

温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 作者简介&#xff1a;Java领…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023