c++类构造函数、拷贝函数 、 赋值函数、析构函数

类的拷贝控制

构造函数、拷贝函数 、 赋值函数、析构函数

  class Sales_data{public:Sales_data() = default;// 默认合成 默认构造函数Sales_data(const Sales_data& ) =  default;// 默认合成 拷贝构造函数Sales_data& operator=(const Sales_data&);//  拷贝赋值运算符~Sales_data() = default;// 默认合成 默认析构函数};

Sales_data& Sales_data::operator=(const Sales_data&) = default;// 拷贝赋值运算符 类外定义

使用 delete 删除函数 避免拷贝

   struct NoCopy(){// struct 默认为 publicNoCopy() = default;//  默认合成 默认构造函数    不能是删除函数NoCopy(const NoCopy&) = delete;// 阻止拷贝NoCopy&  operator=(const NoCopy&);//  阻止赋值~NoCopy() = default;// 默认合成 默认析构函数   不能是删除函数};

private 拷贝控制  用户可定义和删除该对象 但不能拷贝它们   不过该类的成员函数 和其 有元函数和有元类 可以 拷贝

  class privateCopy{// class 默认为 private  普通用户无法访问privateCopy(const privateCopy&);// 私有拷贝构造函数privateCopy& operator=(const privateCopy&);// 私有拷贝赋值运算符public:privateCopy() = default; // 默认合成  默认构造函数~privateCopy() = default;// 默认合成 默认析构函数   不能是删除函数

};

指针 与 拷贝构造函数 和 拷贝赋值运算符

  struct Node{char* name;//名字 字符指针int age;// 年龄Node(char* n = " ", int a = 0 ){//默认构造函数name = strdup(n);// strdup()字符串拷贝库函数age = a;}// 拷贝构造函数未定义     编译器自动生成一个(自动生成的 只是逐个对成员复制,遇到指针就会出问题)// 拷贝赋值运算符也未定义 编译器自动生成一个(自动生成的 只是逐个对成员复制,遇到指针就会出问题) };// 执行拷贝时 指针对象会指向同一个对象Node node1("Role", 20), node2(node1);//使用node1 初始化 node2 strcpy(node2.name, "Wendy");// 指向了同一个对象node2.age = 30;// 非指针正常赋值cout << node1.name << " " << node1.age << " " << node2.name << " " << node2.age << endl;// Wendy  20  Wendy  30  //

定义 拷贝构造函数

  struct Node{char* name;//名字 字符指针int age;// 年龄Node(char* n = " ", int a = 0 ){//默认构造函数name = strdup(n);// strdup()字符串拷贝库函数age = a;}// 拷贝构造函数Node(const Node& n){name = strdup(n.name);age = n.age;}// 拷贝赋值运算符也未定义 编译器自动生成一个  (自动生成的 只是逐个对成员复制,遇到指针就会出问题)};Node node1("Role", 20), node2(node1);//使用node1 初始化 node2  使用拷贝构造函数strcpy(node2.name, "Wendy");node2.age = 30;// 正常赋值cout << node1.name << " " << node1.age << " " << node2.name << " " << node2.age << endl;

// Role 20 Wendy 30  //

定义拷贝赋值运算符  重载 赋值运算符

  struct Node{char* name;//名字 字符指针int age;// 年龄Node(char* n = " ", int a = 0 ){//默认构造函数name = strdup(n);// strdup()字符串拷贝库函数age = a;}// 拷贝构造函数Node(const Node& n){name = strdup(n.name);age = n.age;}// 拷贝赋值运算符Node& operate=(const Node& n){if(this != &n){// 确保赋值运算符的两边不是同一个类的同一个对象，避免重复 定义自己if(name != 0) free(name);//先释放之前的内存（如果之前已经指向了内存，避免内存泄漏）name = strdup(n.name);// 再用 等号 左边的对象初始化 对象age = n.age;}return  *this;// this 起始就是 类对象的地址}};

指针与析构函数  默认的析构函数 只会释放 指针所占据的内存 而不会释放指针指向的内存空间  会造成 内存泄漏

struct Node{
char* name;//名字 字符指针
int age;// 年龄
Node(char* n = " ", int a = 0 ){//默认构造函数
name = strdup(n);// strdup()字符串拷贝库函数
age = a;
}

   // 拷贝构造函数Node(const Node& n){name = strdup(n.name);age = n.age;}// 拷贝赋值运算符Node& operate=(const Node& n){if(this != &n){// 确保赋值运算符的两边不是同一个类的同一个对象，避免重复 定义自己if(name != 0) free(name);//先释放之前的内存（如果之前已经指向了内存，避免内存泄漏）name = strdup(n.name);// 再用 等号 左边的对象初始化 对象age = n.age;}return  *this;// this 起始就是 类对象的地址}

// 定义析构函数
      ~Node(){
      if(name != 0) free(name);//指针不为空，就已经使用了指向的内存，需要free手动释放掉
      }
     
};

通过函数返回引用类型  可以改变类内变量的访问方式   破坏了 隐藏域

  class refTest{public:int& getRefN(){return n;//n为类内私有变量 返回该私有变量引用后 类外就可以访问它}int getN(){return n;//n为类内私有变量}private:int n;} c;//c.n = 6;// 错误  外部直接访问不了 类内私有变量int& k = c.getRefN();//通过返回引用 可以间接访问修改  类内私有变量k = 7;//  类内私有变量 n 被修改为 7cout << c.getN();// 可以看到 n 被修改为 7c.getRefN() = 10;//直接通过 c.getRefN() 来给 类内私有变量 n 赋值

重载

重载输出运算符 <<  为特定类对象 重载输出运算符 返回的是 ostream& 输出流对象的引用

// 一般定义成 非成员函数 在{};外面ostream& operator<<(ostream& os, const Sales_data& item ){os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();// 使用了 字符串的、int、double的 输出运算符 类构成类的 输出运算符return os;

}

重载 输入 运算符 >>  返回的是 istream& 输入流对象的引用

  istream& operator>>(istream& is, const Sales_data& item ){double price;// 单价is >> item.bookNo >> item.units_sold >> price;if(is)//检测输入是否成功item.revenue = item.units_sold * priceelseitem = Sales_data();//输入失败，对象呗赋予默认的状态return is;

}

重载 关系运算符  ==  不等于也类似 !=

// 关系运算符  返回类型为 bool  输入两个类对象的 常量 引用 避免拷贝 节省时间 常量限制 避免修改
   bool
operator==(const Sales_item &lhs, const Sales_item &rhs)
{
       // 在类中被是定义为 friend 有元函数
// friend bool operator==(const Sales_item&, const Sales_item&);// 重定向 等于符号 ==
       return lhs.units_sold == rhs.units_sold &&
lhs.revenue == rhs.revenue &&
lhs.isbn() == rhs.isbn();
}

整体 浏览

    #ifndef SALESITEM_H// we're here only if SALESITEM_H has not yet been defined #define SALESITEM_H// Definition of Sales_item class and related functions goes here#include <iostream>#include <string>class Sales_item {// these declarations are explained section 7.2.1, p. 270 // and in chapter 14, pages 557, 558, 561// 操作符 定义friend std::istream& operator>>(std::istream&, Sales_item&);// 重定向输入 >> 符号friend std::ostream& operator<<(std::ostream&, const Sales_item&);// 重定向输出 << 符号friend bool operator<(const Sales_item&, const Sales_item&);// 重定向 小于符号 < friend bool operator==(const Sales_item&, const Sales_item&);// 重定向 等于符号 ==  public:// constructors are explained in section 7.1.4, pages 262 - 265// default constructor needed to initialize members of built-in typeSales_item() = default;Sales_item(const std::string &book): bookNo(book) { }Sales_item(std::istream &is) { is >> *this; }public:// operations on Sales_item objects// member binary operator: left-hand operand bound to implicit this pointerSales_item& operator+=(const Sales_item&);// operations on Sales_item objectsstd::string isbn() const { return bookNo; }double avg_price() const;// private members as beforeprivate:std::string bookNo;      // implicitly initialized to the empty stringunsigned units_sold = 0; // explicitly initializeddouble revenue = 0.0;};// used in chapter 10inlinebool compareIsbn(const Sales_item &lhs, const Sales_item &rhs) { return lhs.isbn() == rhs.isbn(); }// nonmember binary operator: must declare a parameter for each operandSales_item operator+(const Sales_item&, const Sales_item&);inline bool operator==(const Sales_item &lhs, const Sales_item &rhs){// must be made a friend of Sales_itemreturn lhs.units_sold == rhs.units_sold &&lhs.revenue == rhs.revenue &&lhs.isbn() == rhs.isbn();}inline bool operator!=(const Sales_item &lhs, const Sales_item &rhs){return !(lhs == rhs); // != defined in terms of operator==}// assumes that both objects refer to the same ISBNSales_item& Sales_item::operator+=(const Sales_item& rhs) {units_sold += rhs.units_sold; revenue += rhs.revenue; return *this;}// assumes that both objects refer to the same ISBNSales_item operator+(const Sales_item& lhs, const Sales_item& rhs) {Sales_item ret(lhs);  // copy (|lhs|) into a local object that we'll returnret += rhs;           // add in the contents of (|rhs|) return ret;           // return (|ret|) by value}std::istream& operator>>(std::istream& in, Sales_item& s){double price;in >> s.bookNo >> s.units_sold >> price;// check that the inputs succeededif (in)s.revenue = s.units_sold * price;else s = Sales_item();  // input failed: reset object to default statereturn in;}std::ostream& operator<<(std::ostream& out, const Sales_item& s){out << s.isbn() << " " << s.units_sold << " "<< s.revenue << " " << s.avg_price();return out;}double Sales_item::avg_price() const{if (units_sold) return revenue/units_sold; else return 0;}

#endif

模板类

  template<class genType>//声明模板类型class genClass{genType storage[50];//模板类型 数组};// 定义genClass<int>    intObject;   // int 类型数组genClass<double> doubleObject;// double 类型数组// 其二也可以将 数组大小推迟定义template<class genType, int size = 50>// 声明模板类型 书序大小默认为50class genClass{genType storage[size];//模板类型 数组};// 定义genClass<int>    intObject1;         // int 类型数组 默认   大小genClass<int, 100>    intObject2;    // int 类型数组 数组大小为 100 genClass<double, 123> doubleObject;  // double 类型数组  数组大小为 123

模板函数

  // 交换两个变量的值template<class genType>//声明模板类型void my_swap(genType& num1, genType& num2){   // 注意为 引用 需要对实参修改genType temp = num1;num1 = num2;num2 = temp;}

类的 继承

  #include <iostream> using namespace std;// 基类 class BaseClass {public://共有类型 哪里都可以访问 BaseClass() { }//默认构造函数 void f(char *s = "unknown") {cout << "Function f() in BaseClass called from " << s << endl;h();//类内可以访问 类的私有函数 }protected:// 保护类型  子类 和 友元函数/有元类 可以访问 void g(char *s = "unknown") {cout << "Function g() in BaseClass called from " << s << endl;}private:// 类内 和 元函数/有元类 可以访问 void h() {cout << "Function h() in BaseClass\n";}};// 子类 Derived1Level1 共有继承自 基类   BaseClass class Derived1Level1 : public virtual BaseClass {public:void f(char *s = "unknown") {cout << "Function f() in Derived1Level1 called from " << s << endl;g("Derived1Level1");// 本子类没有重写g() 因此调用的是 父类的g() 保护类型可以继承 子类内可以访问 // 函数时调用的基类的 但是参数 还是按子类传入的  h("Derived1Level1");// 本子类重写了h()(本身父类的为私有，子类也调用不了), 因此调用的是 自己的 h() }void h(char *s = "unknown") {cout << "Function h() in Derived1Level1 called from " << s << endl;}};class Derived2Level1 : public virtual BaseClass {public:void f(char *s = "unknown") {cout << "Function f() in Derived2Level1 called from " << s << endl;g("Derived2Level1");// 调用基类的g() 保护类型的函数  但是参数按 子类传入的参数  // h(); // 错误 : h()为基类的 私有函数 ，子类访问不了 BaseClass::h() is not accessible}};//二级继承 class DerivedLevel2 : public Derived1Level1, public Derived2Level1 {public:void f(char *s = "unknown") {cout << "Function f() in DerivedLevel2 called from " << s << endl;g("DerivedLevel2");// g()函数只有基类有 实现 调用的是基类的 保护继承g() 但是参数是 子类 最新传递的 Derived1Level1::h("DerivedLevel2");// 父亲Derived1Level1有h()  爷爷 也有h() 需要指定调用的哪一个  参数都是最新的 BaseClass::f("DerivedLevel2");// f()函数  两个父亲 和 一个爷爷都有实现，需要指明调用哪一个  参数都是最新的 }};int main() {BaseClass bc;//基类 Derived1Level1 d1l1;//子类1 Derived2Level1 d2l1;//子类2 DerivedLevel2 dl2;//子类的子类 bc.f("main(1)");// // bc.g(); // 错误: 保护类型 类外访问不了 BaseClass::g() is not accessible// bc.h(); // 错误: 私有类型 类外访问不了 BaseClass::h() is not accessiblecout << "---------------"<< endl; d1l1.f("main(2)");//首先调用子类重写的 f() // 内部调用了 基类的g()(函数时调用的基类的 但是参数 还是按子类传入的 ) 和 自身重写的 h() // d1l1.g(); // 错误: 在子类内 可以访问父类的保护类型函数g(), 外面访问不了 BaseClass::g() is not accessibled1l1.h("main(3)");// 调用子类自己重写的函数 参数按最新传入的 d2l1.f("main(4)");// 调用子类的函数f(),内部调用了父类的b保护类型函数g() 但是参数按子类传入的参数 // d2l1.g(); // 父类的保护函数g() 在子类内可以访问 ，外部访问不了 错误 BaseClass::g() is not accessible// d2l1.h(); // 父类的私有函数 子类内，外部都访问不了 错误: BaseClass::h() is not accessibledl2.f("main(5)");//类自身f() 内部 爷爷的 g() 父亲1的 h() 爷爷的  f()  参数都是最新传入的 // dl2.g(); // error: BaseClass::g() is not accessibledl2.h();//外部能访问 父亲  Derived1Level1的 共有类型函数 h() return 0;}/*Function f() in BaseClass called from main(1)Function h() in BaseClassFunction f() in Derived1Level1 called from main(2)Function g() in BaseClass called from Derived1Level1Function h() in Derived1Level1 called from Derived1Level1Function h() in Derived1Level1 called from main(3)Function f() in Derived2Level1 called from main(4)Function g() in BaseClass called from Derived2Level1Function f() in DerivedLevel2 called from main(5)Function g() in BaseClass called from DerivedLevel2Function h() in Derived1Level1 called from DerivedLevel2Function f() in BaseClass called from DerivedLevel2Function h() in BaseClassFunction h() in Derived1Level1 called from unknown--------------------------------Process exited with return value 0Press any key to continue . . .*/

类的多态性  基类定义的虚函数，子类(其他类)可以重写，根据指针当前指向的对象类型动态调用属于哪一确定类的该虚函数

  多态性指的是获得多种形态的能力。在 OOP 中，多态性指的是用同样的函数名称表示多个函数，而这些函数是不同对象的成员。对于所谓的静态绑定来说，调用哪个函数是在编译阶段确定的。而对于动态绑定，则要推迟到运行阶段才能确定。在 C++中，动态绑定是通过将成员函数声明为 virtual 来实现的。在这种方式中，如果对虚函数成员进行调用，那么选择执行哪个函数并不依赖于声明的指针类型，而是依赖于指针当前指向的类型。#include <iostream>using namespace std;//类1 class Class1 {public:virtual void f() {//虚函数   支持动态绑定 运行时确定 cout << "Function f() in Class1\n";}void g() {// 静态绑定 在编译阶段确定 cout << "Function g() in Class1\n";}};// 类2 class Class2 {public:virtual void f() {//虚函数   支持动态绑定 运行时确定 cout << "Function f() in Class2\n";}void g() {cout << "Function g() in Class2\n";}};//类3 class Class3 {public:virtual void h() {//虚函数   支持动态绑定 运行时确定 cout << "Function h() in Class3\n";}};int main() {Class1 object1, *p;// 类1 对象 object1  指针 p 声明为 Class1*类型Class2 object2;// 类2 对象 object2Class3 object3;// 类3 对象 object3p = &object1;//当前p 指向  Class1类的  object1对象  p->f();// 动态绑定 到 Class1类的 f()虚函数     Function f() in Class1p->g();// 静态绑定 在编译阶段确定              Function g() in Class1p = (Class1*) &object2;// 当前p 指向  Class2类的  object2对象 p->f();// 动态绑定 到 Class2类的 f()虚函数     Function f() in Class2p->g();// 静态绑定 在编译阶段确定              Function g() in Class1p = (Class1*) &object3;// 当前p 指向  Class3类的  object3对象 p->f(); // 程序会结束 报错  Class3类 无虚函数  f()   devc测试 竟然输出了  Function h() in Class3p->g(); // 静态绑定 在编译阶段确定             Function g() in Class1//p->h(); // h() is not a member of Class1;return 0;}/* 该程序的输出如下所示：Function f() in Class1Function g() in Class1Function f() in Class2Function g() in Class1// 程序会结束    Class3类 无虚函数  f()   devc测试 竟然输出了  Function h() in Class3Function g() in Class1*/

多态性  优点

  多态性是 OOP 的一项强大功能。可以利用这个特性将一个标准消息发送给许多不同的对象，而不需要指定如何处理消息，也不需要知道对象是什么类型。接收者负责解释和处理消息。发送者不需要根据接收者的类型来修改消息，也不需要使用 switch 或 if-else 语句。此外还可以在复杂的程序中加入新的单元而不需要重新编译整个程序。

有元函数 有元类 拓展了C++隐藏特性

  class C {int n;//class 默认 属性为 provide 私有friend class B;//有元类friend int f();//有元函数} obc;int f(){return 10 * obc.n; // 函数f() 可以访问 类C的对象 obc 的所有类型的变量和方法}class B {// 函数B 可以访问 类C的对象 obc 的所有类型的变量和方法int m;int function(){return  obc.n;}}

函数运算符的重载 类   函数运算符 () operator()

  class classfuc{public:classfuc() {// 默认构造函数}double operator() (double x){// 重载函数运算符 ()return 2*x;}double dou(double x){//定义功能函数return 2*x}};//定义使用 重载了函数运算符的类 定义的函数double sum2(classfuc f, int n, int m){double res = 0.0;for (int i = n; i < = m; ++i){res += f(i); // res += f.dou(i);//使用 功能函数}return res;}// 使用函数classfuc fc;cout << sum2(cf, 2, 10) << endl;

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

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

相关文章

智慧公厕与传统公共厕所对比五大优势是什么？

智慧公厕与传统公共厕所对比五大优势是什么？

随着科技的不断发展&#xff0c;智慧公厕成为城市建设的新亮点。与传统公共厕所相比&#xff0c;它具备许多独特优势和巨大的价值。本文将以智慧公厕领先厂家广州中期科技有限公司&#xff0c;大量精品案例项目实景实例实图&#xff0c;深入探讨智慧公厕的各个方面的特点&#…
阅读更多...
c-const修饰指针-day16

c-const修饰指针-day16

阅读更多...
【VINS】苹果手机采集单目相机+IMU数据离线运行VINS-Mono

【VINS】苹果手机采集单目相机+IMU数据离线运行VINS-Mono

0.准备工作 开个新坑&#xff0c;之前用Android手机做过离线采集数据的实验&#xff0c;这次用IPhone来测试&#xff01; 1.虚拟机配置Mac OS 下载一个Mac OS 的ios镜像&#xff0c;打开虚拟机按照跟Ubuntu差不多的方式安装&#xff0c;但是发现没有Mac OS的入口。 因为VMwa…
阅读更多...
[C++随笔录] stack queue模拟实现

[C++随笔录] stack queue模拟实现

stack && queue模拟实现 stack的实现stack测试用例queue的实现queue测试用例deque stack的实现 &#x1f5e8;️stack的容器适配器应该选什么比较好呢? 首先, stack的特点是 头部入, 尾部出 ⇒ 尾插 和 尾删操作比较频繁 我们前面学过的容器有 vector 和 list, vecto…
阅读更多...
Vue中如何进行图表绘制

Vue中如何进行图表绘制

Vue中的图表绘制&#xff1a;数据可视化的艺术 数据可视化是现代Web应用程序的重要组成部分之一。Vue.js作为一种流行的JavaScript框架&#xff0c;提供了许多强大的工具和库&#xff0c;用于在前端应用程序中创建各种图表和数据可视化。本文将深入探讨在Vue中进行图表绘制的方…
阅读更多...
以太网协议介绍（ARP、UDP、ICMP、IP）

以太网协议介绍（ARP、UDP、ICMP、IP）

以太网协议介绍 一、ARP协议 请求&#xff1a; 应答&#xff1a; ARP协议&#xff1a; 0x0001 0x0800 6 4硬件类型&#xff1a;2个字节&#xff0c;arp协议不仅能在以太网上运行还能在其他类型的硬件上运行。以太网用1来表示&#xff1b; 协议类型&#xff1a;两字节。指的是a…
阅读更多...
【深入了解Java String类】

【深入了解Java String类】

目录 String类 常用方法 字符串的不可变性 String的内存分析 StringBuilder类 解释可变和不可变字符串 常用方法 面试题&#xff1a;String&#xff0c;StringBuilder&#xff0c;StringBuffer之间的区别和联系 String类的OJ练习 String类 【1】直接使用&#xff0c…
阅读更多...
【JUC并发编程--java线程】

【JUC并发编程--java线程】

文章目录 1. 线程1.1 线程的使用线程运行原理 1. 线程 1.1 线程的使用 方法一&#xff0c;直接使用 Thread&#xff1a; 方法二&#xff0c;使用 Runnable 配合 Thread&#xff1a; 把【线程】和【任务】&#xff08;要执行的代码&#xff09;分开 Thread 代表线程Runnabl…
阅读更多...
Java基础面试，String,StringBuffer,StringBuilder区别以及使用场景

Java基础面试，String,StringBuffer,StringBuilder区别以及使用场景

简单的几句 String是final修饰的&#xff0c;不可变&#xff0c;每次操作都会产生新的对象。StringBuffer和StringBuilder都是在原对象上进行操作StringBuffer是线程安全的&#xff0c;StringBuilder是线程不安全的。StringBuffer方法是被synchronized修饰的 所以在性能方面大…
阅读更多...
百度2024校招机器学习、数据挖掘、自然语言处理方向面试经历

百度2024校招机器学习、数据挖掘、自然语言处理方向面试经历

本文介绍2024届秋招中&#xff0c;百度的机器学习/数据挖掘/自然语言处理工程师岗位一面的面试基本情况、提问问题、代码题目等。 8月初参与了百度提前批的机器学习/数据挖掘/自然语言处理工程师岗位面试&#xff0c;所在部门是搜索方向的。一面结束之后就知道凉了&#xff0c;…
阅读更多...
为什么都说NFS读写性能差，如何进行优化？

为什么都说NFS读写性能差，如何进行优化？

使用基于NFS协议存储系统的同学经常遇到的问题是在小文件比较多的情况下性能会比较差。小文件访问性能差本身是可以理解的，但是NFS确实是太差了。不知大家是否深层次分析过，为什么NFS访问小文件性能会这么差？ NFS文件系统与本地文件系统的差异在于多了一个网络传输的过程。…
阅读更多...
shell脚本之环境变量

shell脚本之环境变量

文章目录 常见系统的环境变量用户定义的环境变量 常见系统的环境变量 常见的环境变量&#xff1a; 1&#xff09;$HOME 当前用户的家目录路径。 2&#xff09;$UID和$EUID 当前用户的用户ID和有效用户ID。 3&#xff09;$PPID 当前进程的父进程的进程ID。 4&#xff09;$P…
阅读更多...
毛玻璃用户卡交互

毛玻璃用户卡交互

效果展示 页面结构组成 从效果展示可以看到&#xff0c;此效果都是比较常规的。主要的核心就是卡片的悬停效果。 CSS 知识点 backdrop-filter 回顾transitiontransform 页面基础布局实现 <section><div class"container"><div class"card&q…
阅读更多...
react create-react-app v5配置 px2rem （暴露 eject方式）

react create-react-app v5配置 px2rem （暴露 eject方式）

环境信息&#xff1a; create-react-app v5 “react”: “^18.2.0” “postcss-plugin-px2rem”: “^0.8.1” 配置步骤&#xff1a; 我这个方式是 npm run eject 暴露 webpack配置的方法 1.安装 postcss-plugin-px2rem 和 lib-flexible cnpm install postcss-plugin-px2rem…
阅读更多...
二叉树和堆

二叉树和堆

二叉树不存在度大于2的结点&#xff08;每个根最多只有两个子结点&#xff09;二叉树的子树有左右之分&#xff0c;次序不能颠倒&#xff0c;因此二叉树是有序树 两个特殊的二叉树——&#xff08;满二叉树&#xff0c;完全二叉树&#xff09; 满二叉树——每个根结点都有左右…
阅读更多...
Ubuntu镜像源cn.arichinve.ubuntu.com不可用原因分析和解决

Ubuntu镜像源cn.arichinve.ubuntu.com不可用原因分析和解决

文章目录 Ubuntu查看系统版本Ubuntu更新系统不能更新Ubuntu查看APT更新源配置cn.archive.ubuntu.com已经自动跳转到清华镜像站Ubuntu变更镜像源地址备份原文件批量在VIM中变更 Ubuntu国内镜像站推荐推荐阅读 今天想要在Ubuntu环境下搭建一个测试环境&#xff0c;进入Ubuntu系统…
阅读更多...
react create-react-app v5 从零搭建项目

react create-react-app v5 从零搭建项目

前言&#xff1a; 好久没用 create-react-app做项目了&#xff0c;这次为了个h5项目&#xff0c;就几个页面&#xff0c;决定自己搭建一个&#xff08;ps:mmp 好久没用&#xff0c;搭建的时候遇到一堆问题&#xff09;。 我之前都是使用 umi 。后台管理系统的项目 使用 antd-…
阅读更多...
MySQL学习笔记27

MySQL学习笔记27

MySQL主从复制的核心思路&#xff1a; 1、slave必须安装相同版本的mysql数据库软件。 2、master端必须开启二进制日志&#xff0c;slave端必须开启relay log 日志。 3、master主服务器和slave从服务器的server-id号不能一致。 4、slave端配置向master端来同步数据。 master…
阅读更多...
南京大学【软件分析】07 Interprocedural Analysis

南京大学【软件分析】07 Interprocedural Analysis

文章目录 1. Motivation2. Call graph Construction&#xff08;CHA&#xff09;2.1 方法分派Method Dispatch2.2 方法签名method signature2.3 案例&#xff1a;查找Dispatch2.4 CHA2.5 通过CHA构造调用图 3. Interprocedural Control-Flow Graph4. Interprocedural Data-Flow…
阅读更多...
Open Book LLM Science Exam

Open Book LLM Science Exam

工作太忙&#xff0c;导致完全没有时间学习了。国庆期间&#xff0c;抽空找个baseline继续学习一波 https://www.kaggle.com/code/jjinho/open-book-llm-science-exam/notebook 首先将维基百科数据都保存为faiss index&#xff0c;根据train训练集的prompt选择最相似的3个 t…
阅读更多...
最新文章

Copyright @ 2022~2023