C++进阶语法——OOP（面向对象）【学习笔记（四）】

文章目录

      • 1、C++ OOP⾯向对象开发
        • 1.1 类（classes）和对象（objects）
        • 1.2 public、private、protected访问权限
        • 1.3 实现成员⽅法
        • 1.4 构造函数（constructor）和 析构函数（destructor）
          • 1.4.1 构造函数（constructor）
          • 1.4.2 析构函数（destructor）
        • 1.5 代理构造函数（delegating constructor）
        • 1.6 拷⻉构造函数（copy constructor）
        • 1.7 浅拷贝（shallow copy）和深拷贝（deep copy）
          • 1.7.1 浅拷⻉（shallow copy）
          • 1.7.2 深拷⻉（deep copy）
        • 1.8 在类中使⽤const
        • 1.9 在类中使⽤static
        • 1.10、 struct 和 class区别

1、C++ OOP⾯向对象开发

1.1 类（classes）和对象（objects）

简单介绍一下类：

• C++ 类（classes）
------->• 创建对象⽤的蓝图（blueprint）
------->• ⽤户⾃定义的数据类型
------->• 有成员属性（data）和成员⽅法（methods）
------->• 可以隐藏属性和⽅法（private）
------->• 可以提供公共接⼝（public）
• 示例： Account, Student, std::vector, std::string

简单介绍一下对象：

• C++ 对象（objects）
------->• 由类创建⽽来
------->• 表示类的⼀个具体的实例（Instance）
------->• 可以有很多个实例，每个都有独⽴的身份
------->• 每个对象都可以使⽤类中定义的⽅法
• Account对象示例：
------->• Jobs、Alice 的account是Account类的实例
------->• 每个实例都有它的余额、可以提现、存钱

虽然 int 不是类，这里把它看成一个类，int 后面的 high_score 和 low_score 可以看成 int 类实例化后的对象；
创建 Account 类后，实例化2个对象，分别是：jobs_account 和 alice_account；
std是类，后面跟着的容器 vector 和字符串 string 是对象；
如下图所示，

在这里插入图片描述

A、声明一个类：

在这里插入图片描述

B、创建类的对象：

还可以根据类创建一个指针，并且在堆上使用关键字 new 动态分配内存空间，使用后用 delete 删除释放内存空间，

在这里插入图片描述

一旦有了类的对象，就可以像 C++ 其他变量去使用

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>using namespace std;class Account
{// 属性string name {"None"};double balance {0.0};// 方法bool deposit(double amount); // 存款bool withdraw(double amount); // 取款
};int main()
{Account jobs_account;  // 初始化属性Account alice_account;  // 初始化属性Account accounts [] {jobs_account, alice_account}; // 数组vector<Account> accounts_vec {jobs_account}; // vectoraccounts_vec.push_back(alice_account);Account *p_account = new Account(); // 指针delete p_account;return 0;
}

C、获取类的属性或⽅法：

使⽤点操作符：

在这里插入图片描述

如果是⼀个指向对象的指针，可以解引⽤或者使⽤箭头操作符，
需要注意： 使用 . 操作符的时候需要在前面加一个括号 () ，因为 . 操作符的优先级高于 * 解引用运算符的优先级，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>using namespace std;class Account
{
public:    // 属性string name {"None"};double balance {0.0};// 方法bool deposit(double amount){balance += amount;cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << endl;return true;}; // 存款bool withdraw(double amount){if (balance >= amount){balance -= amount;cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << endl;return true;} else {cout << name << "余额不足，取款失败" << endl;return false;}}; // 取款
};int main()
{Account jobs_account;jobs_account.name = "Jobs";jobs_account.balance = 1000.0;jobs_account.deposit(500.0);Account *alice_account = new Account();(*alice_account).name = "Alice";alice_account->balance = 2000.0;(*alice_account).deposit(1000.0);alice_account->withdraw(500.0);return 0;
}
1.2 public、private、protected访问权限

• public
----->• 可以被任何实体访问
• private
----->• 只能被本类的⽅法访问
• protected
----->• 可以被本类和⼦类（继承）的⽅法访问

在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>using namespace std;class Account
{
private:    // 属性string name {"None"};double balance {0.0};public:// 方法bool deposit(double amount){balance += amount;cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << endl;return true;}; // 存款bool withdraw(double amount){if (balance >= amount){balance -= amount;cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << endl;return true;} else {cout << name << "余额不足，取款失败" << endl;return false;}}; // 取款
};int main()
{Account jobs_account;// jobs_account.name = "Jobs";// jobs_account.balance = 1000.0;// cout << jobs_account.name << "的余额为" << jobs_account.balance << "元" << endl;jobs_account.deposit(500.0);return 0;
}
1.3 实现成员⽅法

在类中定义成员方法，适用于代码量较少的程序，

在这里插入图片描述

在类外面定义成员方法，适用于代码量较大的程序，

在这里插入图片描述

代码：

编译器无法区分 set_name 函数是类内的函数还是其他函数，所以在 set_name 前面添加类名::，表示这是类的成员函数，

#include <iostream>
#include <string>
#include <vector>using namespace std;class Account
{
private:// 属性string name {"None"};double balance {0.0};public:// 方法// 设置余额void set_balance(double amount){balance = amount;};// 获取余额double get_balance(){return balance;};// 设置名称void set_name(string name);// 获取名称string get_name();// 存款bool deposit(double amount);// 取款bool withdraw(double amount);
};void Account::set_name(string name){this->name = name; // this指针指向当前对象
}
string Account::get_name(){return name;
}
bool Account::deposit(double amount){balance += amount;cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << endl;return true;
}
bool Account::withdraw(double amount){if (balance >= amount){balance -= amount;cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << endl;return true;} else {cout << name << "余额不足，取款失败" << endl;return false;}
}int main()
{Account alice_account;alice_account.set_name("Alice's account"); // 设置名称alice_account.set_balance(1000.0); // 设置余额cout << alice_account.get_name() << "的余额为" << alice_account.get_balance() << "元" << endl;alice_account.deposit(200.0);alice_account.withdraw(500.0);alice_account.withdraw(1500.0);return 0;
}

上面的代码看着比较繁杂，我们可以用头文件和源文件编写。
为了防止头文件被多次导入造成一些冲突，一般添加如下语句，关于头文件被多次导入造成一些冲突可参考这个链接：CSDN链接，例如创建 Account.h 头文件：

#ifndef ACCOUNT_H
#define ACCOUNT_H
#endif // ACCOUNT_H

整个 Account.h 头文件代码如下，一般不在头文件写 using namespace std;，一般显示地使用 std:string，

#ifndef ACCOUNT_H
#define ACCOUNT_H
#include <string>class Account
{
private:// 属性std::string name {"None"};double balance {0.0};public:// 方法// 设置余额void set_balance(double amount){balance = amount;};// 获取余额double get_balance(){return balance;};// 设置名称void set_name(std::string name);// 获取名称std::string get_name();// 存款bool deposit(double amount);// 取款bool withdraw(double amount);
};#endif // ACCOUNT_H

然后再根据头文件编写类的成员方法的定义，因为在源文件引入了头文件#include "Account.h"，所以不需要再写 #include <string>，这里也是显示地引入 std::cout，std::endl，

#include "Account.h"
#include <iostream>void Account::set_name(std::string name){this->name = name; // this指针指向当前对象
}
std::string Account::get_name(){return name;
}
bool Account::deposit(double amount){balance += amount;std::cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << std::endl;return true;
}
bool Account::withdraw(double amount){if (balance >= amount){balance -= amount;std::cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << std::endl;return true;} else {std::cout << name << "余额不足，取款失败" << std::endl;return false;}
}

最后是程序的 main.cpp 文件，直接编译 main.cpp 即可，

#include <iostream>
#include <string>
#include <vector>
#include "Account.h" // 引入头文件using namespace std;int main()
{Account alice_account;alice_account.set_name("Alice's account"); // 设置名称alice_account.set_balance(1000.0); // 设置余额cout << alice_account.get_name() << "的余额为" << alice_account.get_balance() << "元" << endl;alice_account.deposit(200.0);alice_account.withdraw(500.0);alice_account.withdraw(1500.0);return 0;
}
1.4 构造函数（constructor）和 析构函数（destructor）
1.4.1 构造函数（constructor）

• 特殊的成员⽅法
• 对象创建的时候⾃动调⽤
• 适⽤于实例参数初始化
• 函数名和类的名称⼀致
• ⽆需设置返回类型
• 可以被重载（overload）

1.4.2 析构函数（destructor）

• 特殊的成员⽅法
• 函数名和类的名称⼀致，前⾯跟着⼀个~波浪符号
• 对象销毁的时候⾃动调⽤
• 没有参数，没有返回类型
• 只有⼀个析构函数（不能重载）
• 适⽤于释放内存等资源

如果不手动创建构造函数和析构函数，那么C++会自动帮助创建构造函数和析构函数，只不过都是空的，

构造函数（constructor）和析构函数（destructor）：

在这里插入图片描述

构造函数在栈上创建，当程序运行结束时，他们各自的析构函数会被调用，所以会调用4次析构函数，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性std::string name {"account"};double balance {0.0};
public:void setName(string name){ this->name = name; }; // 设置名称// 构造函数Account(){cout << "没有参数的构造函数被调用" << endl;};Account(std::string name){cout << "带string name参数的构造函数被调用" << endl;};Account(double balance){ cout << "带double balance参数的构造函数被调用" << endl;};Account(string name, double balance){ cout << "带string name和double balance参数的构造函数被调用" << endl;};// 析构函数~Account(){ cout << name << " 的析构函数被调用" << endl;};
};int main()
{// 用{}表示作用域，{}内的程序运行后会调用析构函数{Account alice_account;alice_account.setName("Alice's account"); // 设置名称}// 出栈：后入先出{Account jobs_account;jobs_account.setName("Jobs's account"); Account bill_account("Bill's account");bill_account.setName("Bill's account"); Account steve_account(1000.0);steve_account.setName("Steve's account"); }Account *mark_account = new Account("Mark's account", 1000.0);mark_account->setName("Mark's account");delete mark_account;return 0;
}

输出：

没有参数的构造函数被调用
Alice's account 的析构函数被调用
没有参数的构造函数被调用
带string name参数的构造函数被调用
带double balance参数的构造函数被调用
Steve's account 的析构函数被调用
Bill's account 的析构函数被调用
Jobs's account 的析构函数被调用
带string name和double balance参数的构造函数被调用
Mark's account 的析构函数被调用

构造函数初始化列表：

:name {name} 中，冒号后面的 name 类成员属性的 name，{} 里面的 name 是函数的形参 name，

在这里插入图片描述

代码1：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性std::string name {"account"};double balance {0.0};
public:// 打印信息void printInfo();// 构造函数，初始化参数Account(string name, double balance);};void Account::printInfo(){cout << "name: " << name << ", balance: " << balance << endl;
}
// 构造函数内部初始化参数
Account::Account(string name, double balance){this->name = name;this->balance = balance;
}int main()
{Account *mark_account = new Account("Mark's account", 1000.0);mark_account->printInfo(); // 打印信息delete mark_account;return 0;
}

输出：

name: Mark's account, balance: 1000

代码2：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性std::string name {"account"};double balance {0.0};
public:// 打印信息void printInfo();// 构造函数，初始化参数Account();Account(string name);Account(string name, double balance);};void Account::printInfo(){cout << "name: " << name << ", balance: " << balance << endl;
}// 构造函数内部初始化参数
// Account::Account(){
//     name = "None";
//     balance = 0.0;
// }
// Account ::Account(string name){
//     this->name = name;
//     balance = 0.0;
// }
// Account::Account(string name, double balance){
//     this->name = name;
//     this->balance = balance;
// }// 构造函数初始化列表
Account::Account():name{"none"}, balance{0.0}{}
Account::Account(string name):name{name}, balance{0.0}{}Account::Account(string name, double balance):name{name}, balance{balance}{}int main()
{Account alice_account;alice_account.printInfo(); // 打印信息Account jobs_account {"Jobs's account"};jobs_account.printInfo(); Account bill_account {"Bill's account", 1000.0};bill_account.printInfo(); return 0;
}

输出：

name: none, balance: 0
name: Jobs's account, balance: 0
name: Bill's account, balance: 1000
1.5 代理构造函数（delegating constructor）

• 重载的构造函数很相似
• 冗余的代码可能会导致错误
• C++ 允许使⽤代理构造函数
------>• 在⼀个构造函数初始化列表中调⽤另⼀个构造函数

代码： 建议使用 debug 查看程序运行过程

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性std::string name {"account"};double balance {0.0};
public:// 打印信息void printInfo();// 构造函数，初始化参数Account();Account(string name);Account(string name, double balance);};void Account::printInfo(){cout << "name: " << name << ", balance: " << balance << endl;
}// 构造函数初始化列表
Account::Account():Account {"none",0}{}
Account::Account(string name):Account {name, 0}{}Account::Account(string name, double balance):name{name}, balance{balance}{}int main()
{Account alice_account;alice_account.printInfo(); // 打印信息Account jobs_account {"Jobs's account"};jobs_account.printInfo(); Account bill_account {"Bill's account", 1000.0};bill_account.printInfo(); return 0;
}

输出：

name: none, balance: 0
name: Jobs's account, balance: 0
name: Bill's account, balance: 1000
1.6 拷⻉构造函数（copy constructor）

• 当对象被拷⻉时，C++必须从已存在的对象复制出⼀个新的对象
• 何时使⽤拷⻉构造函数？
------->• 以值传递⽅式传递对象给函数（作参数）
------->• 函数以值⽅式返回对象
------->• 使⽤已存在的对象复制新的对象
• 如果不提供⾃⼰写的copy constructor，编译器会⾃动⽣成⼀个（可能不符合要求），如果是指针，拷贝的是地址，所以编译器自动生成的拷贝构造函数是浅拷贝，

A、拷⻉构造函数——值传递

在这里插入图片描述

B、拷⻉构造函数——以值⽅式返回

以值⽅式返回拷⻉构造函数返回的 an_account 副本

在这里插入图片描述

C、拷⻉构造函数——使⽤已存在的对象复制新的对象

在这里插入图片描述

D、拷⻉构造函数的声明

首先拷⻉构造函数也是构造函数，所以函数的名称和类的名称一样，函数的参数列表是使用引用的方式传递的，

在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性string name {"account"};double balance {0.0};
public:string getName() {return name;} // 获取namedouble getBalance() {return balance;} // 获取balance// 构造函数Account(string name = "none", double balance = 0.0);// 析构函数~Account();// 拷贝构造函数Account(const Account &source);
};Account::Account(string name, double balance):name {name}, balance {balance}{cout << "2个参数的构造函数被调用，name：" << name << endl;}Account::~Account()
{cout << "析构函数被调用，name：" << name << endl;
}// 拷贝构造函数：根据已存在对象的属性来更新新对象的属性（name,balance）
Account::Account(const Account &source):name {source.name}, balance {source.balance} // 初始化列表{cout << "拷贝构造函数被调用，是" << source.name << "的拷贝" << endl;}
// 打印账户信息
void printAccountInfo(Account acc)
{cout << acc.getName() << "的余额是：" << acc.getBalance() << endl;
}
int main()
{// 1.值传递的方式给函数传递参数// Account alice_account;// printAccountInfo(alice_account);// 2.基于已存在的对象创建新的对象Account alice_account {"Alice's account", 1000.0};Account new_account {alice_account}; // 拷贝构造函数被调用return 0;
}

输出：

2个参数的构造函数被调用，name：Alice's account
拷贝构造函数被调用，是Alice's account的拷贝
析构函数被调用，name：Alice's account
析构函数被调用，name：Alice's account
1.7 浅拷贝（shallow copy）和深拷贝（deep copy）

• 如果不提供⾃⼰写的copy constructor，编译器会⽣成默认的
------>• 将⽬标对象的值逐个拷⻉过来；
------>• 如果是指针，拷⻉的是值（指向的地址），⽽不是指向的对象，称为浅拷贝
------>• 在析构函数中释放内存时，其他对象中的指针可能还在指向被释放的资源，在析构函数释放内存资源时可能会报错，例如下面的代码，如果使用编译器默认的拷贝构造函数，在进行析构函数释放内存资源时可能会报错

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性string name {"account"};double *balance {nullptr};
public:double get_balance() {return *balance;}; // 获取余额string get_name() {return name;}; // 获取名字// 构造函数Account(string name = "none", double balance = 0.0); // 有默认参数的构造函数// 拷贝构造函数Account(const Account &source);// 析构函数~Account();};
Account::Account(string name, double balance){this->name = name;this->balance = new double {balance}; // 堆上分配内存cout << "2个参数的构造函数被调用，name: " << name << endl;}
// 拷贝构造函数    
Account::Account(const Account &source):Account {source.name, *source.balance} // 代理构造函数{cout << "拷贝构造函数被调用，是" << source.name << "的拷贝" << endl;} Account::~Account(){if (balance != nullptr)delete balance; // 释放内存cout << "析构函数被调用，name: " << name << endl;
}int main()
{// 演示浅拷贝和深拷贝Account alice_account {"Alice", 1000.0};Account new_account {alice_account}; // 拷贝构造函数被调用// cout << new_account.get_balance() << endl; // 1000.0return 0;
}

如果使用编译器默认的拷贝构造函数，在进行 alice_account 析构函数释放内存时会报错，如下图，如果使用自己写的拷贝构造函数就不会报错，

在这里插入图片描述

1.7.1 浅拷⻉（shallow copy）

如下图，alice_account 浅拷贝到 new_account，编译器会默认创建一个拷贝构造函数，它是逐个元素按值拷贝的，如果是指针，则是拷贝的地址。当调用析构函数的时候，由于后进先出的原则，new_account 上的地址被释放后，alice_account 的地址也会被释放，但地址已经被释放，所以会造成堆空间重复释放的问题，导致程序报错，

在这里插入图片描述

编译器默认生成的拷贝构造函数如下：

在这里插入图片描述

1.7.2 深拷⻉（deep copy）

在函数内部，在堆上分配一个新的 double 类型的内存空间，初始化为1000，并且把新的内存空间给1000，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性string name {"account"};double *balance {nullptr};
public:double get_balance() {return *balance;}; // 获取余额string get_name() {return name;}; // 获取名字// 构造函数Account(string name = "none", double balance = 0.0); // 有默认参数的构造函数// 拷贝构造函数Account(const Account &source);// 析构函数~Account();};
Account::Account(string name, double balance){this->name = name;this->balance = new double {balance}; // 堆上分配内存cout << "2个参数的构造函数被调用，name: " << name << endl;}
// 拷贝构造函数    
Account::Account(const Account &source):Account {source.name, *source.balance} // 代理构造函数{cout << "拷贝构造函数被调用，是" << source.name << "的拷贝" << endl;} Account::~Account(){if (balance != nullptr)delete balance; // 释放内存cout << "析构函数被调用，name: " << name << endl;
}int main()
{// 演示浅拷贝和深拷贝Account alice_account {"Alice", 1000.0};Account new_account {alice_account}; // 拷贝构造函数被调用// cout << new_account.get_balance() << endl; // 1000.0return 0;
}
1.8 在类中使⽤const

• 常函数
------->• 函数名称后加const
------->• 函数体内不可以修改类成员属性
• 常对象
------->• 声明对象时前⾯加const
------->• 不可以修改常对象的成员属性
------->• 不能调用普通的成员方法，只能调⽤常函数

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:double balance {0.0};public:string name {"account"};void set_new_name(string new_name) const{ // 修改名字// name = new_name;}string get_name() const{ // 获取名字return name;}// 构造函数Account(string name = "none", double balance = 0.0);~Account();
};Account::Account(string name, double balance): balance{balance} ,name{name}{cout << "构造函数" << endl;
}Account::~Account()
{cout << "析构函数" << endl;
}int main()
{// 常函数// Account alice_account {"Alice", 1000.0};// alice_account.set_new_name("Alice2"); // 修改名字// cout << alice_account.get_name() << endl; // Alice2// 常对象const Account bob_account {"Bob", 2000.0};// bob_account.name = "Bob2"; // 修改名字cout << bob_account.get_name() << endl; // Bob2return 0;
}
1.9 在类中使⽤static

• 静态成员变量
------->• 所有对象共有同⼀份数据（数据共享）
------->• 在类中声明，类外初始化
• 静态成员函数
------->• 所有对象共享同⼀个函数
------->• 只能访问静态成员变量

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;class Account
{
private:// 属性string name {"account"};double balance {0.0};static int num_accounts;
public:static int get_num_accounts();Account(string name, double balance);~Account();
};int Account::num_accounts {0};Account::Account(string name, double balance):name{name}, balance{balance}{num_accounts++;}Account::~Account()
{num_accounts--;
}int Account::get_num_accounts() // 不需要使用static关键字
{// 静态成员方法只能访问静态成员变量// name = "test";return num_accounts;
}
int main()
{cout << Account::get_num_accounts() << endl;Account alice_account {"Alice's account", 1000.0};cout << alice_account.get_num_accounts() << endl;Account bob_account {"Bob's account", 2000.0};cout << Account::get_num_accounts() << endl;{Account test_account {"test", 100.0};cout << Account::get_num_accounts() << endl;}cout << Account::get_num_accounts() << endl;return 0;
}
1.10、 struct 和 class区别

区别在于 class 成员权限默认是 private，而 struct 的成员权限默认是 public，

在这里插入图片描述

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

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

相关文章

ubuntu 22.04安装百度网盘

ubuntu 22.04安装百度网盘

百度网盘 客户端下载 (baidu.com) 下载地址 sudo dpkg -i baidunetdisk_4.17.7_amd64.deb
阅读更多...
tftp服务的搭建

tftp服务的搭建

TFTP服务的搭建 1 先更新一下apt包 sudo apt-get update2 服务器端(虚拟机上)安装 TFTP相关软件 sudo apt-get install xinetd tftp tftpd -y3 创建TFTP共享目录 mkdir tftp_sharetftp_shaer的路径是/home/cwz/tftp_share 3.1 修改共享目录的权限 sudo chmod -R 777 tftp…
阅读更多...
北邮22级信通院数电：Verilog-FPGA（7）第七周实验（1）：带使能端的38译码器全加器（关注我的uu们加群咯~）

北邮22级信通院数电：Verilog-FPGA（7）第七周实验（1）：带使能端的38译码器全加器（关注我的uu们加群咯~）

北邮22信通一枚~ 跟随课程进度更新北邮信通院数字系统设计的笔记、代码和文章 持续关注作者 迎接数电实验学习~ 获取更多文章&#xff0c;请访问专栏&#xff1a; 北邮22级信通院数电实验_青山如墨雨如画的博客-CSDN博客 关注作者的uu们可以进群啦~ 目录 方法一&#xff…
阅读更多...
Python第三方库 - Flask(python web框架)

Python第三方库 - Flask(python web框架)

1 Flask 1.1 认识Flask Web Application Framework&#xff08; Web 应用程序框架&#xff09;或简单的 Web Framework&#xff08; Web 框架&#xff09;表示一个库和模块的集合&#xff0c;使 Web 应用程序开发人员能够编写应用程序&#xff0c;而不必担心协议&#xff0c;线…
阅读更多...
时序预测 | Python实现ARIMA-LSTM自回归移动差分模型结合长短期记忆神经网络时间序列预测

时序预测 | Python实现ARIMA-LSTM自回归移动差分模型结合长短期记忆神经网络时间序列预测

时序预测 | Python实现ARIMA-LSTM自回归移动差分模型结合长短期记忆神经网络时间序列预测 目录 时序预测 | Python实现ARIMA-LSTM自回归移动差分模型结合长短期记忆神经网络时间序列预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 时序预测 | Python实现ARIMA-LSTM自…
阅读更多...
K8s概念汇总-笔记

K8s概念汇总-笔记

目录 1.Master 1.1在Master上运⾏着以下关键进程 2.什么是Node? 1.2在每个Node上都运⾏着以下关键进程 3.什么是 Pod ? 4. 什么是Label &#xff1f; 5.Replication Controller 6.Deployment 6.1Deployment的典型场景&#xff1a; 7.Horizontal Pod Autoscaler TODO…
阅读更多...
『力扣刷题本』：合并两个有序链表（递归解法）

『力扣刷题本』：合并两个有序链表（递归解法）

一、题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#x…
阅读更多...
部署 CNI网络组件

部署 CNI网络组件

部署 flannel K8S 中 Pod 网络通信&#xff1a; ●Pod 内容器与容器之间的通信 在同一个 Pod 内的容器&#xff08;Pod 内的容器是不会跨宿主机的&#xff09;共享同一个网络命令空间&#xff0c; 相当于它们在同一台机器上一样&#xff0c;可以用 localhost 地址访问彼此的端口…
阅读更多...
微信小程序如何利用接口返回经纬计算实际位置并且进行导航功能【下】

微信小程序如何利用接口返回经纬计算实际位置并且进行导航功能【下】

如果要在微信小程序内部导航的话可以使用wx.navigateToMiniProgram方法来打开腾讯地图小程序&#xff0c;并传递目的地的经纬度信息。 目录 1.如何获取高精地址 2.如何调起地图 3.实现效果 navigateToDestination: function() {let that this;var latitude parseFloa…
阅读更多...
流程引擎-自定义函数的应用

流程引擎-自定义函数的应用

背景&#xff1a; 某些业务需求比较特殊&#xff0c;需要在表单中校验或实现一些功能&#xff0c;泛微流程表单配置时实现的方式多种多样&#xff1a;JS脚本、SQL语句、公式以及其他一些标准化拖拽功能&#xff0c;本次给大家分享一下流程表单中的公式实现的一些需求场景。泛微…
阅读更多...
lunar-1.5.jar

lunar-1.5.jar

公历农历转换包 https://mvnrepository.com/artifact/com.github.heqiao2010/lunar <!-- https://mvnrepository.com/artifact/com.github.heqiao2010/lunar --> <dependency> <groupId>com.github.heqiao2010</groupId> <artifactId>l…
阅读更多...
【收藏】药物专利信息查询方法-经典实操案例！

【收藏】药物专利信息查询方法-经典实操案例！

生物医药领域在专利行业中&#xff0c;一直是独特的存在。药物专利在各国之间有不同的登记要求&#xff0c;如何在这种查询方式诸多局限的情况下&#xff0c;检索得更全更准呢&#xff1f; 作为一名医药行业的IPR&#xff0c;经常需要调研药物原研专利。 大家所熟知的最快捷的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023