关于隐藏、覆盖（重写）、重载的理解

定义区分

  • 在派生-对象中：优先考虑隐藏，此时派生类中的覆盖(重写)也是隐藏;没有隐藏的情况下，子类对象才能调用父类重载函数。[此时感觉virtual没用，]
  • 在派生-指针或者引用中：只用覆盖(重写)和重载;
    注：C++ Primmer P550解释为：D1的fnc并没有覆盖(重写)Base的虚函数fnc…实际上，D1…此时拥有了两个名为fnc的函数：一个是D1从Base继承而来的(隐藏的)虚函数fnc;另一个是D1自己定义的接受的接受int参数的非虚函数fnc。

其他有利于理解的说法：如果派生类定义了一个与基类成员函数同名的函数（无论参数列表是否相同），那么派生类中的这个函数将隐藏基类中的所有同名函数（隐藏仅仅指类的对象，对于指向派生类的基类指针仍然可以调用其他虚函数）

下面是我写的两个函数示例(后续优化)

/*
* 知识点：隐藏、覆盖(重写)、重载
* One:对于隐藏、覆盖(重写)
*     在派生-对象中：优先考虑隐藏，此时派生类中的覆盖(重写)也是隐藏;没有隐藏的情况下，子类对象才能调用父类重载函数。[此时感觉virtual没用，]
*     在派生-指针或者引用中：只用覆盖(重写)和重载;
*
*
其他有利于理解的说法
* 如果派生类定义了一个与基类成员函数同名的函数（无论参数列表是否相同），
* 那么派生类中的这个函数将隐藏基类中的所有同名函数（隐藏仅仅指类的对象，
* 对于指向派生类的基类指针仍然可以调用其他虚函数）
*/#include <iostream>
using namespace std;class Base
{
public:Base(int a) : m_v(a) {}virtual void setM() { m_v = 0; }virtual void setM(int a) { m_v = a; }virtual int getM() { return m_v; }
protected:int m_v;
};class Drive : public Base
{
public:Drive() : Base(42) {}void setM() override { m_v = 1000; } // 使用 override 关键字明确这是一个重写的方法
};class DDrive : public Drive
{
public:DDrive() : Drive() {}
};int main()
{Base b(6);cout << "Base: " << b.getM() << endl;  // 输出 6b.setM();cout << "Base setM() default(0): " << b.getM() << endl;  // 输出 0，因为调用了 Base 的 setM()b.setM(9);cout << "Base setM(9): " << b.getM() << endl;  // 输出 9cout << endl;Drive d;cout << "Drive Base default(): " << d.getM() << endl; // 输出 42，因为 Drive 的构造函数调用了 Base(42)d.setM();cout << "Drive setM() default(0): : " << d.getM() << endl; // 输出 1000，因为调用了 Drive 的 setM()//d.setM(1001);   // Error:函数调用参数过多;派生类对象对父类进行隐藏//cout << "Drive (1001) : " << d.getM() << endl; // 输出 1000，因为调用了 Drive 的 setM()// 以下部分展示了多态性Base* pb = &b;cout << "Base: " << pb->getM() << endl;  // 输出 9pb->setM();cout << "Base: " << pb->getM() << endl;  // 输出 0，因为 pb 指向 Base 对象，调用了 Base 的 setM()pb->setM(9);cout << "Base: " << pb->getM() << endl;  // 输出 9Base* pd = &d;cout << "Drive: " << pd->getM() << endl; // 输出 1000pd->setM();cout << "Drive: " << pd->getM() << endl; // 输出 1000，因为 pd 指向 Drive 对象，调用了 Drive 的 setM()pd->setM(1001);cout << "Drive: " << pd->getM() << endl; // 输出 1001，因为调用了 Drive 的 setM(int)// 延申：子类的不恰当隐藏会影响到孙类"!!!对象!!!",但并不影响孙类指针DDrive dd;cout << "Drive Base default(): " << dd.getM() << endl;dd.setM();cout << "Drive setM() default(0): : " << dd.getM() << endl;//dd.setM(1001);    // Error:函数调用参数过多;子类的不恰当隐藏会影响到孙类!!!对象!!!cout << "Drive (1001) : " << dd.getM() << endl;Base* pdd = &dd;cout << "Drive: " << pdd->getM() << endl;pdd->setM();cout << "Drive: " << pdd->getM() << endl;pdd->setM(1001);cout << "Drive: " << pdd->getM() << endl;return 0;
}

还有个更长的示例

#include <iostream>
using namespace std;/*
*一、
*在C++中，重写（Override）和隐藏（Hiding）是两个不同的概念，它们在某些情况下可能会产生冲突或混淆，尤其是在涉及继承时。
但是，这两个概念本身并不直接冲突，而是需要开发者明确理解和区分它们以避免潜在的问题。- 重写（Override）
重写发生在子类中，当子类提供了一个与基类中的虚函数具有相同签名（即相同的函数名、返回类型、参数列表）的成员函数时。
这允许子类改变从基类继承的虚函数的行为。重写是动态绑定的一部分，因此当通过基类指针或引用调用重写的虚函数时，将调用子类中的版本（如果指针或引用实际上指向子类对象）。- 隐藏（Hiding）
隐藏也发生在子类中，但它通常与名称冲突相关。当子类提供了一个与基类中的非虚函数具有相同名称的成员函数时，基类的该函数在子类中将被隐藏。
这意味着在子类的**对象**直接调用该函数时，将调用子类中的版本，而不是基类中的版本。
但是，如果通过基类指针或引用调用该函数（即使该指针或引用实际上指向子类对象），仍然会调用基类中的版本（除非基类中的函数也是虚函数）。*冲突和混淆
- 重写和隐藏之间的主要混淆在于它们都与函数名和继承有关，但行为却截然不同。如果开发者不清楚何时发生重写、何时发生隐藏，可能会导致意外的行为。
- 此外，如果基类中的函数被设计为虚函数（以支持多态），但子类中的同名函数没有被声明为override（在C++11及更高版本中支持），并且基类中的函数签名在子类中发生了更改（例如参数数量或类型不同），
那么子类中的函数实际上将隐藏基类中的虚函数，而不是重写它。
这可能导致代码中的错误，因为开发者可能期望实现多态行为，但实际上却得到了隐藏行为。为了避免这种混淆，建议：
- 在子类中重写基类的虚函数时，使用override关键字（如果编译器支持）。这将使编译器在基类中没有匹配的虚函数时发出错误。
- 尽量避免在子类中隐藏基类中的非虚函数，除非这是有意为之。如果必须这样做，请确保在文档和注释中清楚地说明这一点。
- 理解多态、重写和隐藏的概念，并始终注意在涉及继承时的函数签名和访问级别。*二、如果你遇到d2.doSomething(3.14)不能调用Base类的doSomething(double a)方法的情况，可能有几个原因：①隐藏基类方法：如果在Derived2或它的直接基类Derived中有任何重载版本的doSomething方法，并且没有使用using声明来引入基类的方法，基类的方法可能会被隐藏。
这意味着，即使基类中存在doSomething(double a)，如果派生类中定义了其他版本的doSomething（如doSomething(int)或doSomething(char)），
但没有显式地引用基类的方法，基类版本的方法在派生类对象上可能无法直接访问。
②名称隐藏：在C++中，如果派生类中定义了与基类相同名称的成员函数，即使参数列表不同，基类中的同名函数也会被隐藏。
这是C++的名称隐藏规则，不同于重载。
③访问控制：如果Base类的doSomething方法是protected或private，则不能在Derived2类的对象上直接调用它（尽管这种情况不太可能，因为你提到了virtual，这通常意味着方法应该是public的）。另一方面，dp2->doSomething(3.14);可以工作，可能是因为dp2是一个指向Derived2的指针，但是被当做Base类的指针来使用。
当你通过基类指针调用一个virtual函数时，C++的多态性确保调用的是指针实际指向的对象的最具体的实现（即动态绑定）。
如果Derived2没有重载doSomething(double a)，则调用会回退到Base类的实现。如果d2.doSomething(3.14)不工作，而dp2->doSomething(3.14);工作，最可能的原因是名称隐藏。
在派生类中定义新的doSomething函数时，如果没有正确地使用using声明来引入基类的函数，基类的同名函数会被隐藏
*/class Base {
public:virtual void doSomething(int a) {// 基类的doSomething(int)方法  std::cout << "Base::doSomething(int) called with " << a << std::endl;}virtual void doSomething(char a) {// 基类的doSomething(double)重载方法  std::cout << "Base::doSomething(char) called with " << a << std::endl;}virtual void doSomething(int a, int b, int c) {// 基类的doSomething(double)重载方法  std::cout << "Base::doSomething(int a,int b, int c) called with a:" << a << ", b：" << b << ", c：" << c << std::endl;}void doSomething(int a, int b, int c, int d) {// 基类的doSomething(double)重载方法  std::cout << "Base::doSomething(int a, int b, int c, int d) called with a:" << a << ", b：" << b << ", c：" << c << ", d：" << d << std::endl;}void coutName() {// 基类的coutName重载方法  std::cout << "Base::coutName" << std::endl;}
};class Derived1 : public Base {
public://using Base::doSomething;void doSomething(int a) {// 派生类重写了基类的doSomething(int)方法  std::cout << "Derived1::doSomething(int) called with " << a << std::endl;}//using Base::doSomething;void doSomething(char c) {// 派生类重写了基类的doSomething(char c)方法  std::cout << "Derived1::doSomething(char) called with " << c << std::endl;}
};class Derived2 : public Base {
public://using Base::doSomething;void doSomething(int a) {// 派生类重写了基类的doSomething(int)方法  std::cout << "Derived2::doSomething(int) called with " << a << std::endl;}virtual void doSomething(int a, int b, int c, int d) {// 派生类重写了基类的doSomething(int a, int b, int c, int d)方法  std::cout << "Derived2::doSomething(double) called with a:" << a << ", b：" << b << ", c：" << c << ", d：" << d << std::endl;}
};class Derived3 : public Base {
public://using Base::doSomething;void doSomething(int a) {// 派生类重写了基类的doSomething(int)方法  std::cout << "Derived3::doSomething(int) called with " << a << std::endl;}//using Base::doSomething;void doSomething(int x, int y) {// 派生类重载了doSomething(int x, int y)方法std::cout << "Derived3::doSomething(int x, int y) called with x:" << x << ",y:" << y << std::endl;}
};class Derived11 : public Derived1 {
public://using Base::doSomething;void doSomething(int a) {// 派生类重写了基类的doSomething(int)方法  std::cout << "Derived11::doSomething(int) called with " << a << std::endl;}
};class Derived21 : public Derived2 {
public://using Base::doSomething;void doSomething(int a) {// 派生类重写了基类的doSomething(int)方法  std::cout << "Derived21::doSomething(int) called with " << a << std::endl;}
};class Derived31 : public Derived3 {
public://using Base::doSomething;void doSomething(int a) {// 派生类重写了基类的doSomething(int)方法  std::cout << "Derived31::doSomething(int) called with " << a << std::endl;}
};int main() {cout << "************************************实例化对象开始表演******************************************************" << endl;Base b1;b1.doSomething(42);//b1.doSomething(3.14);      //  !!!编译报错提示"有多个重载函数 实例与参数列表相同，26和31行"，因为3.14不知道转换为int，还是charb1.doSomething('c');b1.doSomething(1, 2, 3);b1.doSomething(1, 2, 3, 4);b1.coutName();cout << endl << endl;Derived1 d1;d1.doSomething(42);            // 调用Derived1的doSomething(int)  //d1.doSomething(3.14);          // !!!编译报错提示"有多个重载函数 实例与参数列表相同，56和62行"，因为3.14不知道转换为int，还是chard1.doSomething('c');           // !!!'c'转化内int//d1.doSomething(1, 2, 3);     // !!!报错提示"没有与参数列表匹配的 重载函数Derived1::doSomething, 参数类型为(int, int, int)"//d1.doSomething(1, 2, 3, 4);  // !!!报错提示"没有与参数列表匹配的 重载函数Derived1::doSomething, 参数类型为(int, int, int, int)"d1.coutName();                 // 调用基类的doSomething(double)，因为派生类没有重写它  cout << endl << endl;Derived2 d2;d2.doSomething(42);    // 调用Derived2的doSomething(int)  d2.doSomething(3.14);  // 3.14转换为int,调用相同d2.doSomething('c');   // 'c'转化内int//d2.doSomething(1, 2, 3);//!!!报错提示"没有与参数列表匹配的 重载函数Derived2::doSomething, 参数类型为(int, int, int)"d2.doSomething(1, 2, 3, 4); //!!!这是Derived2自身的函数，与Base没有关系d2.coutName();         // 调用基类的doSomething(double)，因为派生类没有重写它 // !!!子类Derived3::doSomething(int x, int y),是否对父类方法进行隐藏。也就是说d3是否拥有doSomething(double a)？？？cout << endl << endl;Derived3 d3;d3.doSomething(42);    // 调用Derived2的doSomething(int)  d3.doSomething(3.14);  // 3.14转换为int,调用相同d3.doSomething('c');   // 'c'转化内int//d3.doSomething(1, 2, 3);     // !!!报错提示"没有与参数列表匹配的 重载函数Derived3::doSomething, 参数类型为(int, int, int)"//d3.doSomething(1, 2, 3, 4);  // !!!报错提示"没有与参数列表匹配的 重载函数Derived3::doSomething, 参数类型为(int, int, int, int)"d3.doSomething(1, 2);   //!!!这是Derived3自身的函数，与Base没有关系d3.coutName();         // 调用基类的doSomething(double)，因为派生类没有重写它 cout << endl << endl;cout << "******************创建Derived1、Derived2、Derived3单独的指针(感觉类实例化对象用法一致)*********************************************" << endl;Derived1* opd1 = new Derived1;opd1->doSomething(42);    // 调用Derived1::doSomething(int)  opd1->doSomething('c');   // 调用Derived1::doSomething(char)//opd1->doSomething(1, 2, 3); // !!!报错提示"没有与参数列表匹配的 重载函数Derived1::doSomething, 参数类型为(int, int, int)"//opd1->doSomething(1, 2, 3, 4);// !!!报错提示"没有与参数列表匹配的 重载函数Derived1::doSomething, 参数类型为(int, int, int, int)"opd1->coutName();cout << endl << endl;Derived2* opd2 = new Derived2;opd2->doSomething(42);    // 调用Derived2的doSomething(int)  opd2->doSomething('c');   // 调用Base::doSomething(char)//opd2->doSomething(1, 2, 3);//!!!报错提示"没有与参数列表匹配的 重载函数Derived2::doSomething, 参数类型为(int, int, int)"opd2->doSomething(1, 2, 3, 4); // !!!这是Derived2自身的函数，与Base没有关系opd2->coutName();cout << endl << endl;Derived3* opd3 = new Derived3;opd3->doSomething(42);    // 调用Derived2的doSomething(int)  opd3->doSomething('c');   // 'c'转化内int//opd3->doSomething(1, 2, 3);// !!!报错提示"没有与参数列表匹配的 重载函数Derived3::doSomething, 参数类型为(int, int, int)"//opd3->doSomething(1, 2, 3, 4); // !!!报错提示"没有与参数列表匹配的 重载函数Derived3::doSomething, 参数类型为(int, int, int, int)"opd3->doSomething(1, 2);   // !!!报错提示"没有与参数列表匹配的 重载函数Base::doSomething, 参数类型为(int, int)"opd3->coutName();cout << endl << endl;cout << "******************创建基类指针分别指向Derived1、Derived2、Derived3(virtual在派生类中多态应用)**************************************" << endl;Base* pd1 = new Derived1;pd1->doSomething(42);    // 调用Derived1::doSomething(int)  pd1->doSomething('c');   // 调用Derived1::doSomething(char)pd1->doSomething(1, 2, 3);// 调用Base::doSomething(int, int, int)pd1->doSomething(1, 2, 3, 4);// 调用Base::doSomething(int, int, int, int)pd1->coutName();cout << endl << endl;Base* pd2 = new Derived2;pd2->doSomething(42);    // 调用Derived2的doSomething(int)  pd2->doSomething('c');   // 调用Base::doSomething(char)pd2->doSomething(1, 2, 3);// 调用Base::doSomething(int, int, int)pd2->doSomething(1, 2, 3, 4); // !!! 这里调用基类Base::doSomething(int, int, int, int)，因为不是虚函数，子类Derived2没有对其重写pd2->coutName();cout << endl << endl;Base* pd3 = new Derived3;pd3->doSomething(42);    // 调用Derived2的doSomething(int)  pd3->doSomething('c');   // 'c'转化内intpd3->doSomething(1, 2, 3);// 调用Base::doSomething(int, int, int)pd3->doSomething(1, 2, 3, 4);// 调用Base::doSomething(int, int, int, int)//pd3->doSomething(1, 2);   // !!!报错提示"没有与参数列表匹配的 重载函数Base::doSomething, 参数类型为(int, int)"pd3->coutName();cout << endl << endl;cout << "******************创建Derived11、Derived21、Derived31单独的指针(感觉类实例化对象用法一致)*********************************************" << endl;Derived11* opd11 = new Derived11;opd11->doSomething(42);    // 调用Derived11::doSomething(int)  opd11->doSomething('c');  // 'c'转化内int//opd11->doSomething(1, 2, 3); // !!!报错提示"参数太多",我感觉跟原来哪个意思一样（"没有与参数列表匹配的 重载函数Derived11::doSomething, 参数类型为(int, int, int)"）//opd11->doSomething(1, 2, 3, 4);// !!!报错提示"参数太多"opd11->coutName();cout << endl << endl;Derived21* opd21 = new Derived21;opd21->doSomething(42);    // 调用Derived21的doSomething(int)  opd21->doSomething('c');   // 'c'转化内int//opd21->doSomething(1, 2, 3);// !!!报错提示"参数太多"//opd21->doSomething(1, 2, 3, 4); // !!!报错提示"参数太多"opd21->coutName();cout << endl << endl;Derived31* opd31 = new Derived31;opd31->doSomething(42);    // 调用Derived2的doSomething(int)  opd31->doSomething('c');   // 'c'转化内int//opd31->doSomething(1, 2, 3);;// !!!报错提示"参数太多"//opd31->doSomething(1, 2, 3, 4);;// !!!报错提示"参数太多"//opd31->doSomething(1, 2); ;// !!!报错提示"参数太多"opd31->coutName();cout << endl << endl;cout << "******************创建基类指针分别指向Derived11、Derived21、Derived31(virtual在派生类中多态应用)**************************************" << endl;Base *pd11 = new Derived11;pd11->doSomething(42);    // 调用Derived1::doSomething(int)  pd11->doSomething('c');   // 调用Derived1::doSomething(char)pd11->doSomething(1, 2, 3);// 调用Base::doSomething(int, int, int)pd11->doSomething(1, 2, 3, 4);// 调用Base::doSomething(int, int, int, int)pd11->coutName();cout << endl << endl;Base *pd21 = new Derived21;pd21->doSomething(42);    // 调用Derived2的doSomething(int)  pd21->doSomething('c');   // 调用Base::doSomething(char)pd21->doSomething(1, 2, 3);// 调用Base::doSomething(int, int, int)pd21->doSomething(1, 2, 3, 4); // !!! 这里调用基类Base::doSomething(int, int, int, int)，因为不是虚函数，子类Derived2没有对其重写pd21->coutName();cout << endl << endl;Base* pd31 = new Derived31;pd31->doSomething(42);    // 调用Derived2的doSomething(int)  pd31->doSomething('c');   // 'c'转化内intpd31->doSomething(1, 2, 3);// !!!报错提示"参数太多"pd31->doSomething(1, 2, 3, 4);// !!!报错提示"参数太多"//pd31->doSomething(1, 2);  // !!!报错提示"参数太多"pd31->coutName();cout << endl << endl;return 0;
}

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

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

相关文章

《Programming from the Ground Up》阅读笔记：p19-p48

《Programming from the Ground Up》阅读笔记：p19-p48

《Programming from the Ground Up》学习第2天&#xff0c;p19-p48总结&#xff0c;总计30页。 一、技术总结 1.object file p20, An object file is code that is in the machine’s language, but has not been completely put together。 之前在很多地方都看到object fi…
阅读更多...
高阶K8S面试题你会几个？

高阶K8S面试题你会几个？

前言 K8S架构、公有云、持久化存储、HELM、CICD、负载均衡、监控告警、可观察性、服务治理、架构探索。。。 Q1&#xff1a;如何调试 Kubernetes 集群中的网络连接问题&#xff0c;比如 Pod 间通信失败的情况&#xff1f; 状态检查&#xff1a;使用 kubectl get pods 和 kube…
阅读更多...
MySQL-17-mysql alter 语句如何实现？如何合并为一个

MySQL-17-mysql alter 语句如何实现？如何合并为一个

拓展阅读 MySQL 00 View MySQL 01 Ruler mysql 日常开发规范 MySQL 02 truncate table 与 delete 清空表的区别和坑 MySQL 03 Expression 1 of ORDER BY clause is not in SELECT list,references column MySQL 04 EMOJI 表情与 UTF8MB4 的故事 MySQL 05 MySQL入门教程&a…
阅读更多...
Git使用中遇到的问题（随时更新）

Git使用中遇到的问题（随时更新）

问题1.先创建本地库&#xff0c;后拉取远程仓库时上传失败的问题怎么解决&#xff1f; 操作主要步骤&#xff1a; step1 设置远程仓库地址: $ git remote add origin gitgitee.com:yourAccount/reponamexxx.git step2 推送到远程仓库: $ git push -u origin "master&qu…
阅读更多...
线程池理解及7个参数

线程池理解及7个参数

定义理解 线程池其实是一种池化的技术实现&#xff0c;池化技术的核心思想就是实现资源的复用&#xff0c;避免资源的重复创建和销毁带来的性能开销。线程池可以管理一堆线程&#xff0c;让线程执行完任务之后不进行销毁&#xff0c;而是继续去处理其它线程已经提交的任务。 …
阅读更多...
GStreamer学习5----probe数据探测

GStreamer学习5----probe数据探测

参考资料&#xff1a; gstreamer中如何使用probe&#xff08;探针&#xff09;获取帧数据_gstreamer 视频编码时获取视频关键帧信息-CSDN博客 Gstreamer中可以使用AppSink作为一个分支来查看管线中的数据&#xff0c;还可以使用probe去处理。 在GStreamer中&#xff0c;probe…
阅读更多...
LayerNorm Plugin的使用与说明

LayerNorm Plugin的使用与说明

目录 前言0. 简述1. Layernorm Plugin的使用1.1 源码下载1.2 模型下载和修改1.3 环境配置1.4 编译1.4 engine生成和执行(trtexec)1.5 enging生成和执行(C API) 2. 补充说明2.1 RTMO显存占用问题2.2 插件找不到的说明2.3 LayerNorm plugin封装的尝试2.4 layerNorm plugin核函数实…
阅读更多...
拉曼光谱入门：3.拉曼光谱的特征参数与定量定性分析策略

拉曼光谱入门：3.拉曼光谱的特征参数与定量定性分析策略

1.特征参数 1.1 退偏振率 退偏振率&#xff08;p&#xff09;是一个衡量拉曼散射光偏振状态的参数&#xff0c;它描述了拉曼散射光的偏振方向与入射光偏振方向之间的关系。退偏振率定义为垂直偏振方向的拉曼散射强度与平行偏振方向的拉曼散射强度之比。退偏振率&#xff08;p&…
阅读更多...
禁用windows的语音识别快捷键win+ctrl+s

禁用windows的语音识别快捷键win+ctrl+s

win11组合键winctrls会弹出语音识别提示&#xff0c;即使到设置里禁用了语音识别也没用 解决办法&#xff1a;安装PowerToys&#xff0c;通过“键盘管理器”-“重新映射快捷键”禁用 PowerToys是微软自己的工具&#xff0c;不用担心安全问题&#xff0c;下载地址&#xff1a;h…
阅读更多...
系统设计题-简易数据库系统

系统设计题-简易数据库系统

一、设计一个简易数据库系统&#xff0c;包含create&#xff0c;insert&#xff0c;select三个指令。 create(int tableId,int colNum,String key)&#xff1a;创建表&#xff0c;其id为tableId&#xff0c;如果该表已存在&#xff0c;则不做任何处理。colNum为表中列的数量&a…
阅读更多...
洛谷 P3008 [USACO11JAN] Roads and Planes G

洛谷 P3008 [USACO11JAN] Roads and Planes G

题意 有一张 n n n 点 ( m 1 m 2 ) (m_1m_2) (m1​m2​) 边的无向图&#xff0c;其中 m 1 m_1 m1​ 条为无向边&#xff0c;另外 m 2 m_2 m2​ 条为有向边&#xff0c; 无向边的边权可以为负。求 s s s 到其他每个点的最短路。 思路 使用 SPFA 会 T 掉一两个点&#x…
阅读更多...
第10章：网络与信息安全

第10章：网络与信息安全

目录 第10章&#xff1a;网络与信息安全 网络概述 计算机网络概念 计算机网络的分类 网络的拓扑结构 ISO/OSI网络体系结构 网络互联硬件 物理层互联设备 数据链路层互联设备 网络层互联设备 应用层互联设备 网络的协议与标准 网络标准 TCP/IP协议族 网络接口层协…
阅读更多...
GCC扩展功能、函数，预处理命令

GCC扩展功能、函数，预处理命令

文章目录 前言一、GCC C语言扩展声明函数属性变量属性内敛汇编与原子操作相关的内建函数内存模型感知原子操作的内置函数使用溢出检查执行算术的内置函数 - xxx 二、GCC C语言扩展interface和 pragmasTemplate 二、预处理过程及其指令预处理过程1. 字符集转换2. Initial proces…
阅读更多...
实现基于Spring Cloud的事件驱动微服务

实现基于Spring Cloud的事件驱动微服务

实现基于Spring Cloud的事件驱动微服务 大家好&#xff0c;我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01; 事件驱动架构在现代微服务架构中越来越受欢迎&#xff0c;它通过事件的…
阅读更多...
【JAVA多线程】线程池概论

【JAVA多线程】线程池概论

目录 1.概述 2.ThreadPoolExector 2.1.参数 2.2.新任务提交流程 2.3.拒绝策略 2.4.代码示例 1.概述 线程池的核心&#xff1a; 线程池的实现原理是个标准的生产消费者模型&#xff0c;调用方不停向线程池中写数据&#xff0c;线程池中的线程组不停从队列中取任务。 实现…
阅读更多...
最新版Python安装教程

最新版Python安装教程

一、安装Python 1.下载Python 访问Python官网&#xff1a; https:/www.oython.orgl 点击downloads按钮&#xff0c;在下拉框中选择系统类型(windows/Mac OS./Linux等) 选择下载最新稳定版本的Python 以下内容以演示安装Windows操作系统64位的python 左边是稳定发布版本Stabl…
阅读更多...
python网络编程-TCP/IP

python网络编程-TCP/IP

链路层 帧组成&#xff08;按顺序&#xff09;&#xff1a; 目标MAC&#xff1a;6B 源MAC&#xff1a;6B 类型&#xff1a;2B 数据&#xff1a;46B-1500B CRC&#xff1a;4B 其中&#xff0c;源MAC为主机网卡地址&#xff0c;类型为来源网络层的数据类型&#xff0c;ipv…
阅读更多...
Self-Instruct构造Prompt的例子

Self-Instruct构造Prompt的例子

人工构造一批Prompt做种子。&#xff08;Starting with a small seed set of human-written tasks&#xff09;每次把一些种子后来生成的Prompt&#xff0c;放到Input里做few-shot examples&#xff0c;用LLM生成更多的Prompt&#xff1b;&#xff08;Using the LLM to generat…
阅读更多...
PyTorch学习之torch.transpose函数

PyTorch学习之torch.transpose函数

PyTorch学习之torch.transpose函数 一、简介 torch.transpose 函数我们用于交换张量的维度。 二、语法 torch.transpose 函数用于交换给定张量的两个维度&#xff0c;其语法如下&#xff1a; torch.transpose(input, dim0, dim1)三、参数 input&#xff1a;待交换维度的张…
阅读更多...
kotlin 基础

kotlin 基础

文章目录 1、安装 Java 和 Kotlin 环境2、程序代码基本结构3、变量的声明与使用4、数据类型5、数字类型的运算1&#xff09;布尔类型2&#xff09;字符类型3&#xff09;字符串类型 6、 选择结构1)&#xff08;if - else&#xff09;2&#xff09; 选择结构&#xff08;when&am…
阅读更多...
最新文章

Copyright @ 2022~2023