[c++] c++ 中的顺序(构造，析构，初始化列表，继承)

对象构造的时候，对象成员变量的初始化顺序是什么样的 ？

派生类构造的时候，先构造基类还是先构造派生类 ？

构造函数中的初始化列表，初始化的顺序是列表的顺序吗 ？

析构的时候，析构的顺序是什么样的 ？

本文通过实例代码记录上述场景下的顺序。先说结论：

（1）全局对象以及静态全局对象，在 main 函数调用之前创建

（2）构造时，先构造类中的成员变量，再调用构造函数

（3）类中成员变量的构造顺序是变量在类中声明的顺序

（4）初始化列表中，成员变量的初始化顺序也是变量在类中声明的顺序

（5）对于派生类来说，先构造基类，再构造派生类

（6）对于多重继承的场景，基类构造的顺序是继承列表的顺序

（7）多重继承中如果有虚拟继承，那么先构造虚拟基类

（8）析构的顺序与构造的顺序是相反的

1 静态变量在 main 函数调用之前创建

main 函数是我们应用中第一个执行的函数，但却不是系统加载应用时第一个调用的函数。在 main 函数正式运行前，最基础的这个应用的环境变量如果需要配置则要进行配置；应用入参如果有需要也应该把入参放到规定的位置；对于全局变量和静态全局变量，也是在 main 函数初始化之前构造的。

#include <iostream>
#include <string>
#include <unistd.h>

class Test1 {
public:
  Test1() {
    std::cout << "Test1()" << std::endl;
  }

  ~Test1() {
    std::cout << "~Test1()" << std::endl;
  }
};

class Test2 {
public:
  Test2() {
    std::cout << "Test2()" << std::endl;
  }

  ~Test2() {
    std::cout << "~Test2()" << std::endl;
  }

private:
  static Test1 t1;
};

Test1 Test2::t1;

Test1 t1;
static Test2 t2;

void Do() {
  std::cout << "Do()" << std::endl;
  static Test1 t1;
}

int main() {
  std::cout << "main" << std::endl;
  sleep(2);
  static Test1 t1;
  Do();
  Do();
  return 0;
}

运行结果如下，从结果中还可以看出，对于局部静态变量来说，是在函数第一次调用的时候构造的。这也体现了懒加载的思想，局部静态变量在第一次函数调用之前，根本就没有用，直接构造这个对象是浪费时间和内存资源。

 
使用 gdb 对 Test1 的构造函数设置断点，可以看到 Test1 的调用栈。

2 构造顺序和析构顺序

对于一个没有继承其它类的类来说，构造顺序有以下几点：

（1）构造的时候先构造类的成员变量，再调用构造函数。这也可以理解，符合我们的使用习惯，因为构造函数中可以使用这个对象中的成员变量，所以调用构造函数的时候，成员变量需要初始化好。

（2）成员变量的构造顺序(也叫初始化顺序)是变量在类中声明的顺序。可以猜测，编译器编译的时候是直接按顺序解析类中的成员变量，然后按这个顺序进行初始化的。这样也符合我们的使用习惯，在使用变量的时候，后声明的变量，可能会使用到之前声明的变量，所以从上向下进行初始化。

（3）成员变量的构造顺序和变量的权限是没有关系的，只有一个影响因素，那就是变量在类中的声明顺序。

静态成员是属于类的，不是属于对象的。

静态成员变量在进程中只有一份，被所有对象所共享。

静态成员在程序启动的时候就会创建，而不是在构造对象的时候再创建。

析构顺序，是构造顺序的逆：

（1）先调用析构函数，再析构类中的成员变量

（2）成员变量的析构顺序与变量在类中声明的顺序是相反的

如下是验证代码，代码中有 3 个类 Test1 ~ Test3。另外有 3 个类 Test4 ~ Test5，这 3 个类中有 3 个成员变量，分别是 Test1 ~ Test3，这 3 个变量的声明顺序是不一样的，访问权限也是不一样的。通过这个代码可以观察构造顺序和析构顺序。

#include <iostream>
#include <string>

class Test1 {
public:
  Test1() {
    std::cout << "Test1()" << std::endl;
  }

  ~Test1() {
    std::cout << "~Test1()" << std::endl;
  }
};

class Test2 {
public:
  Test2() {
    std::cout << "Test2()" << std::endl;
  }

  ~Test2() {
    std::cout << "~Test2()" << std::endl;
  }
};

class Test3 {
public:
  Test3() {
    std::cout << "Test3()" << std::endl;
  }

  ~Test3() {
    std::cout << "~Test3()" << std::endl;
  }
};


class Test4 {
public:
  Test4() {
    std::cout << "Test4()" << std::endl;
  }

  ~Test4() {
    std::cout << "~Test4()" << std::endl;
  }

  Test1 test1;
  Test2 test2;
  Test3 test3;
};

class Test5 {
public:
  Test5() {
    std::cout << "Test5()" << std::endl;
  }

  ~Test5() {
    std::cout << "~Test5()" << std::endl;
  }

  Test3 test3;
  Test2 test2;
  Test1 test1;
};

class Test6 {
public:
  Test6() {
    std::cout << "Test6()" << std::endl;
  }

  ~Test6() {
    std::cout << "~Test6()" << std::endl;
  }

private:
  Test3 test3;
  Test2 test2;

public:
  Test1 test1;
};


int main() {
  std::cout << "t4 --------" << std::endl;
  Test4 t4;
  std::cout << "t5 --------" << std::endl;
  Test5 t5;
  std::cout << "t6 --------" << std::endl;
  Test6 t6;
  std::cout << "----------------" << std::endl;
  return 0;
}

运行结果如下：

如下代码，运行结果如下，从运行结果也可以看出来，在调用构造函数的时候，打印 a_ 是 10，这说明在调用构造函数的时候，成员变量已经完成了初始化。

#include <iostream>
#include <string>

class Test {
public:
  Test() {
    std::cout << "Test(), a_ = " << a_ << std::endl;
    a_ = 100;
    std::cout << "a_ = " << a_ << std::endl;
  }

  ~Test() {
    std::cout << "~Test()" << std::endl;
  }

  int a_ = 10;
};

int main() {
  Test t;
  return 0;
}

3 初始化列表

3.1 初始化列表初始化顺序

初始化列表的初始化顺序有以下几点需要注意：

（1）初始化列表中变量初始化的顺序，不是按照列表的顺序，仍然是按照成员变量在类中声明的顺序。

（2）初始化列表中的初始化也是在调用构造函数之前完成。

（3）如果类中的成员变量有的在初始化列表中进行初始化，有的不在初始化列表中进行初始化，整体的初始化顺序仍然是按照变量在类中声明的顺序。

（4）初始化列表中初始化的变量，不会重复初始化。也就是说不会在初始化列表初始化之前初始化一次，到初始化列表中再初始化一次。

如下代码中 Test3 初始化列表中的顺序和变量在类中声明的顺序不一样，变量的构造顺序仍然按照变量在类中声明的顺序初始化；Test5 中，初始化列表中只初始化了 test1，test1 和没有放到初始化列表中的 test2 和 tes3 的相对顺序仍然是它们在类中声明的顺序。

#include <iostream>
#include <string>

class Test1 {
public:
  Test1() {
    std::cout << "Test1()" << std::endl;
  }

  ~Test1() {
    std::cout << "~Test1()" << std::endl;
  }
};

class Test2 {
public:
  Test2() {
    std::cout << "Test2()" << std::endl;
  }

  ~Test2() {
    std::cout << "~Test2()" << std::endl;
  }
};

class Test3 {
public:
  Test3() {
    std::cout << "Test3()" << std::endl;
  }

  ~Test3() {
    std::cout << "~Test3()" << std::endl;
  }
};


class Test4 {
public:
  Test4() : test3(), test1(), test2() {
    std::cout << "Test4()" << std::endl;
  }

  ~Test4() {
    std::cout << "~Test4()" << std::endl;
  }

  Test1 test1;
  Test2 test2;
  Test3 test3;
};

class Test5 {
public:
  Test5() : test1() {
    std::cout << "Test5()" << std::endl;
  }

  ~Test5() {
    std::cout << "~Test5()" << std::endl;
  }

  Test3 test3;
  Test2 test2;
  Test1 test1;
};

class Test6 {
public:
  Test6() : test1(), test2(), test3() {
    std::cout << "Test6()" << std::endl;
  }

  ~Test6() {
    std::cout << "~Test6()" << std::endl;
  }

private:
  Test3 test3;
  Test2 test2;

public:
  Test1 test1;
};


int main() {
  std::cout << "t4 --------" << std::endl;
  Test4 t4;
  std::cout << "t5 --------" << std::endl;
  Test5 t5;
  std::cout << "t6 --------" << std::endl;
  Test6 t6;
  std::cout << "----------------" << std::endl;
  return 0;
}

运行结果如下：

如下代码，两个成员变量 i 和 j，先声明的 i 后声明的 j，所以初始化顺序是先 i 后 j。在初始化列表中对 i 进行初始化的时候，j 还没有初始化，所以 i 是一个随机值，j 是 10。

#include <iostream>
#include <string>

class Test {
public:
  Test(int a) : j(a), i(j) {
    std::cout << "Test(), j = " << j << ", i = " << i << std::endl;
  }

  ~Test() {
    std::cout << "~Test()" << std::endl;
  }

  void Print() {
    std::cout << "Print(), j = " << j << ", i = " << i << std::endl;
  }

private:
  int i;
  int j;
};


int main() {
  std::cout << "main" << std::endl;
  Test t(10);
  t.Print();
  return 0;
}

 运行结果如下：

3.2 const 变量和引用只能在初始化列表中初始化

（1）const 常量和引用必须在初始化列表中进行初始化，不能在构造函数中初始化

（2）const 常量只能在初始化列表中初始化，构造函数和其它地方不能修改

（3）引用在初始化列表中初始化之后，在其它地方也可以进行修改

#include <iostream>
#include <string>

class Test {
public:
  Test(int a, int &b) : a_(a), b_(b) {
    std::cout << "Test(), a = " << a_ << ", b = " << b_ << std::endl;
    // a_ = a; 编译错误
    b_ = b;
  }

  ~Test() {
    std::cout << "~Test()" << std::endl;
  }

  void Print() {
    std::cout << "Print(), a = " << a_ << ", b = " << b_ << std::endl;
  }

private:
  const int a_;
  int &b_;
};

int main() {
  int a = 10;
  int b = 20;
  Test t(a, b);
  t.Print();
  return 0;
};

3.3 基类构造只能在初始化列表中初始化

#include <iostream>
#include <string>

class Base {
public:
  Base(int a, int b) : a_(a), b_(b) {
    std::cout << "Base(), a = " << a_ << ", b = " << b_ << std::endl;
  }

  ~Base() {
    std::cout << "~Base()" << std::endl;
  }

  void Print() {
    std::cout << "Print(), a = " << a_ << ", b_ = " << b_ << std::endl;
  }

public:
  int a_;

private:
  int b_;
};


class Derived : public Base {
public:
  Derived(int data) : Base(data, data * 2), data_(data) {
    // 这句，语法没有错，但是不能起到初始化基类的作用
    // 只是生成了一个基类的临时对象
    // 初始化基类只能在初始化列表中
    Base(data * 10, data * 20);
    std::cout << "Derived()" << std::endl;
  };

  ~Derived() {
    std::cout << "~Derived()" << std::endl;
  }

private:
  int data_;
};

int main() {
  Derived d(10);
  d.Print();
  return 0;
}

4 继承

当派生类构造的时候，先构造基类，再构造派生类。这也是符合常识的，派生类是继承基类而来，没有构造出基类对象，何来派生类对象，派生类对象从哪继承。

4.1 单继承

如下代码，Derived 继承了 Base，构造 Derived 的时候，先构造 Base 再构造 Derived。

#include <iostream>
#include <string>
#include <unistd.h>

class Base {
public:
  Base() {
    std::cout << "Base()" << std::endl;
  }

  ~Base() {
    std::cout << "~Base()" << std::endl;
  }
};

class Derived : public Base {
public:
  Derived() {
    std::cout << "Derived()" << std::endl;
  }

  ~Derived() {
    std::cout << "~Derived()" << std::endl;
  }
};

int main() {
  std::cout << "main" << std::endl;
  Derived d;
  return 0;
}

4.2 多继承

多重继承是一个类可以继承多个类。多重继承意思是一个类需要同时具备多个类的属性，从现实语义上来说，多重继承更像是组合的语义。多继承的语法和语义，让人感觉有点别扭，与常识也是不大符合的，但是 c++ 中支持这种语法。

4.2.1 构造顺序

（1）基类构造的顺序按继承列表的顺序进行构造，而不是按照初始化列表中声明的顺序进行构造

（2）如果有虚拟继承，那么先构造虚拟继承的基类

#include <iostream>
#include <string>
#include <unistd.h>

class Base1 {
public:
  Base1(int a) : a_(a) {
    std::cout << "Base1() a = " << a_ << std::endl;
  }

  ~Base1() {
    std::cout << "~Base1()" << std::endl;
  }

  int a_;
};

class Base2 {
public:
  Base2(int a) : a_(a) {
    std::cout << "Base2() a = " << a_ << std::endl;
  }

  ~Base2() {
    std::cout << "~Base2()" << std::endl;
  }

  int a_;
};

class Base3 {
public:
  Base3(int a) : a_(a) {
    std::cout << "Base3() a = " << a_ << std::endl;
  }

  ~Base3() {
    std::cout << "~Base3()" << std::endl;
  }

  virtual void Do3() {
    std::cout << "Do3, a = " << a_ << std::endl;
  }

  int a_;
};

class Base4 {
public:
  Base4(int a) : a_(a) {
    std::cout << "Base4() a = " << a_ << std::endl;
  }

  ~Base4() {
    std::cout << "~Base4()" << std::endl;
  }

  virtual void Do4() {
    std::cout << "Do4, a = " << a_ << std::endl;
  }

  int a_;
};

class Derived1 : public Base1, public Base2 {
public:
  Derived1() : Base2(20), Base1(10) {
    std::cout << "Derived1()" << std::endl;
  }

  ~Derived1() {
    std::cout << "~Derived1()" << std::endl;
  }
};

class Derived2 : public Base1, public Base2 {
public:
  Derived2() : Base1(100), Base2(200) {
    std::cout << "Derived2()" << std::endl;
  }

  ~Derived2() {
    std::cout << "~Derived2()" << std::endl;
  }
};

class Derived3 : public Base3, public Base4 {
public:
  Derived3() : Base4(400), Base3(30) {
    std::cout << "Derived3()" << std::endl;
  }

  ~Derived3() {
    std::cout << "~Derived3()" << std::endl;
  }
};

class Derived4 : public Base1, public Base4, public Base3, virtual public Base2 {
public:
  Derived4() : Base1(1000), Base2(2000), Base3(3000), Base4(4000) {
    std::cout << "Derived4()" << std::endl;
  }

  ~Derived4() {
    std::cout << "~Derived4()" << std::endl;
  }
};


int main() {
  std::cout << "main" << std::endl;
  std::cout << "d1 --------" << std::endl;
  Derived1 d1;
  std::cout << "d2 --------" << std::endl;
  Derived2 d2;
  std::cout << "d3 --------" << std::endl;
  Derived3 d3;
  std::cout << "d4 --------" << std::endl;
  Derived4 d4;
  return 0;
}

运行结果如下：

（1）Derived1 和 Derived2 都是多继承 Base1 和 Base2，继承列表中顺序是一致的，初始化列表中是不一样的。基类构造顺序都是继承列表的顺序。

（2）Derived4 虚拟继承了 Base2，并且 Base2 在继承声明的最后，构造 Derived4 的时候也是先构造 Base2。

4.2.2 多重继承的二义性以及怎么避免

如下代码，两个基类，Base1 和 Base2，两个基类有两个相同的函数 Speak()。Derived1 类继承自 Base1 和 Base2，当通过 Derived1 对象调用 Speak 的时候，会产生二义性。编译不知道调用的这个 Speak 是 Base1 中的还是 Base2 中的。

消除二义性，可以通过在调用的时候指定是哪个基类中的方法。

#include <iostream>
#include <string>


class Base1 {
public:
  Base1() {
    std::cout << "Base1()" << std::endl;
  }

  ~Base1() {
    std::cout << "~Base1()" << std::endl;
  }

  void Speak(std::string str) {
    std::cout << "Base1 speak: " << str << std::endl;
  }
};

class Base2 {
public:
  Base2() {
    std::cout << "Base2()" << std::endl;
  }

  ~Base2() {
    std::cout << "~Base2()" << std::endl;
  }

  void Speak(std::string str) {
    std::cout << "Base2 speak: " << str << std::endl;
  }
};


class Derived1 : public Base1, public Base2 {
public:
  Derived1() {
    std::cout << "Derived1()" << std::endl;
  }

  ~Derived1() {
    std::cout << "Derived1()" << std::endl;
  }
};

int main() {
  Derived1 d1;
  // d1.Speak(); // 二义性
  d1.Base1::Speak("hello");
  return 0;
}

如下图所示，Derived1 和 Derived2 继承自 Base1，Derived3 继承自 Derived1 和 Derived2。这样当 Derived3 调用 Speak() 的时候就会产生二义性，因为 Speak 在 Derived1 和 Derived2 中各有一份。

有两种方法可以消除这个代码中的二义性，个人更倾向于使用第一种，这样语法清晰。

（1）代码中指定使用哪个类中的函数

d3.Derived1::Speak("hello");

（2）将 Derived1 和 Derived2 改成虚拟继承

#include <iostream>
#include <string>


class Base1 {
public:
  Base1() {
    std::cout << "Base1()" << std::endl;
  }

  ~Base1() {
    std::cout << "~Base1()" << std::endl;
  }

  void Speak(std::string str) {
    std::cout << "Base1 speak: " << str << std::endl;
  }
};

class Derived1 : virtual public Base1 {
public:
  Derived1() {
    std::cout << "Derived1()" << std::endl;
  }

  ~Derived1() {
    std::cout << "Derived1()" << std::endl;
  }
};

class Derived2 : virtual public Base1 {
public:
  Derived2() {
    std::cout << "Derived2()" << std::endl;
  }

  ~Derived2() {
    std::cout << "Derived2()" << std::endl;
  }
};

class Derived3 : public Derived1, public Derived2 {
public:
  Derived3() {
    std::cout << "Derived3()" << std::endl;
  }

  ~Derived3() {
    std::cout << "Derived3()" << std::endl;
  }
};


int main() {
  Derived3 d3;
  d3.Speak("hello"); // 二义性
  return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

评估需求优先级的方法

评估需求优先级的方法

Kano模型&#xff1a; 1.前言 在大量的需求需要进行迭代时&#xff0c;由于时间、人力、财力等相关因素干扰&#xff0c;无法在有限的时间内容对所有的需求进行满足&#xff0c;此时需要我们对需求进行优先级的排列。最大化的合理的提高有限资源的使用。 在常见的产品优先级…
阅读更多...
vcomp140.dll丢失如何修复，5种修复方法轻松搞定vcomp140.dll问题

vcomp140.dll丢失如何修复，5种修复方法轻松搞定vcomp140.dll问题

vcomp140.dll文件的丢失可能会引发一系列系统运行与软件功能上的问题。具体来说&#xff0c;这个动态链接库文件是Visual C Redistributable的一部分&#xff0c;对于许多基于此环境开发的应用程序至关重要。一旦缺失&#xff0c;可能会导致部分应用程序无法正常启动或运行&…
阅读更多...
代码随想录训练营第39天 | LeetCode 62.不同路径、​​​​​​LeetCode 63. 不同路径 II

代码随想录训练营第39天 | LeetCode 62.不同路径、​​​​​​LeetCode 63. 不同路径 II

LeetCode 62.不同路径 文章讲解&#xff1a;代码随想录(programmercarl.com) 视频讲解&#xff1a;动态规划中如何初始化很重要&#xff01;| LeetCode&#xff1a;62.不同路径_哔哩哔哩_bilibili 思路 代码如下&#xff1a; ​​​​​​LeetCode 63. 不同路径 II 文章讲解…
阅读更多...
Java定时调度

Java定时调度

在Java应用程序中&#xff0c;定时调度是一项重要的任务。它允许你安排代码执行的时间&#xff0c;以便在将来的某个时刻自动执行任务。Java提供了多种方式来实现定时调度&#xff0c;其中最常用的是Java的Timer和ScheduledExecutorService。 在本教程中&#xff0c;我们将学习…
阅读更多...
基于C/S架构的在线阅读器

基于C/S架构的在线阅读器

项目简介 本项目实现了用户的基本阅读功能。项目内容涉及到IO&#xff0c;网络编程&#xff0c;C&#xff0c;QT等知识点。本次项目服务器搭建在ubuntu上&#xff0c;客户端ui在QT中实现&#xff0c;客户端和服务器使用套接字通信。 一、基本功能展示 &#xff08;1&#xff…
阅读更多...
开发利器——C语言必备实用第三方库

开发利器——C语言必备实用第三方库

​ 对于广大C语言开发者来说&#xff0c;缺乏类似C STL和Boost的库会让开发受制于基础库的匮乏&#xff0c;也因此导致了开发效率的骤降。这也使得例如libevent这类事件库&#xff08;基础组件库&#xff09;一时间大红大紫。 今天&#xff0c;码哥给大家带来一款基础库&#…
阅读更多...
【开源物联网平台】FastBee认证方式和MQTT主题设计

【开源物联网平台】FastBee认证方式和MQTT主题设计

&#x1f308; 个人主页&#xff1a;帐篷Li &#x1f525; 系列专栏&#xff1a;FastBee物联网开源项目 &#x1f4aa;&#x1f3fb; 专注于简单&#xff0c;易用&#xff0c;可拓展&#xff0c;低成本商业化的AIOT物联网解决方案 目录 一、接入步骤 1.1 设备认证 1.2 设备交…
阅读更多...
思维题（蓝桥杯 填空题 C++）

思维题（蓝桥杯 填空题 C++）

目录 题目一&#xff1a; ​编辑 代码&#xff1a; 题目二&#xff1a; 代码&#xff1a; 题目三&#xff1a; 代码&#xff1a; 题目四&#xff1a; 代码&#xff1a; 题目五&#xff1a; 代码&#xff1a; 题目六&#xff1a; 代码七&#xff1a; 题目八&#x…
阅读更多...
Unity Samples和帧动画的问题

Unity Samples和帧动画的问题

拖动序列帧图片和自己创建clip的帧率不同 我今天在创建帧动画的时候用了两种方式第一种是直接拖动序列帧图片到Hierachy&#xff0c;然后生成的第二种是这样我发现两者播放的动画速率不一样最后查了半天查不到原因。最后发现是Samples的原因&#xff0c;而且Unity把Samples这个…
阅读更多...
自动化测试框架、Python面向对象以及POM设计模型简介

自动化测试框架、Python面向对象以及POM设计模型简介

1 自动化测试框架概述 所谓的框架其实就是一个解决问题的思维&#xff0c;前言中描述的诸多问题如果得到解决&#xff0c;自然而然这种得到良好解决的东西它就可以称之为一个框架&#xff0c;只是这个框架用来解决如何组织开展自动化测试。一个典型的自动化测试框架一般包括测…
阅读更多...
市场复盘总结 20240307

市场复盘总结 20240307

仅用于记录当天的市场情况&#xff0c;用于统计交易策略的适用情况&#xff0c;以便程序回测 短线核心&#xff1a;不参与任何级别的调整&#xff0c;采用龙空龙模式 一支股票 10%的时候可以操作&#xff0c; 90%的时间适合空仓等待 二进三&#xff1a; 进级率中 89% 最常用的…
阅读更多...
[OpenCv]频域处理

[OpenCv]频域处理

目录 前言 一、频域变换 1.傅里叶变换 2.代码实现 二、频域中图像处理 1.理解数字图片的频谱 2.频域图像处理步骤 3.使用低通滤波器实现图像平滑 4.使用高通滤波器实现图像锐化 三、总结 前言 数字图像处理的方法有两大类&#xff1a;一种是空间域处理法&#xff0c;…
阅读更多...
【笔记】Android Telephony 漫游SPN显示定制（Roaming Alpha Tag）

【笔记】Android Telephony 漫游SPN显示定制（Roaming Alpha Tag）

一、功能名词简介和显示规则 Alpha Tag&#xff1a;运营商名称标识符&#xff0c;也是用于标识运营商的一个名称。客户需求描述常用名词&#xff0c;对开发而言都是SPN/PLMN功能模块的内容&#xff0c;状态栏左上角的运营商名称显示。 SPN相关文章&#xff1a; 【笔记】SPN和…
阅读更多...
nyist_acm 个人积分赛1（部分题解会补充）

nyist_acm 个人积分赛1（部分题解会补充）

Mirrored String II 看到题解说是马拉车算法&#xff0c;我赛时并没想到&#xff08;好吧其实我是比赛完才知道有马拉车这个算法&#xff09; 因为字符串的长度只有1000&#xff0c;直接暴力跑其实就可以了&#xff0c;但是要注意的是&#xff1b;回文串有俩种形式&#xff0c…
阅读更多...
nginx部署前端工程替代方案gateway

nginx部署前端工程替代方案gateway

nginx部署前端工程替代方案gateway 有市场要求部署的前端vue工程不使用nginx中间件。想弄国产替代的东方通之类的&#xff0c;公司没有购买该产品&#xff0c;我参考了网上的一些java网关框架&#xff0c;springcloud组件&#xff1a;gateway实现代替。 注意后台都是用java编…
阅读更多...
shadertoy 游戏《来自星尘》摇杆复刻

shadertoy 游戏《来自星尘》摇杆复刻

正确的做法应该是上 noise 而不是叠加 sin 波&#xff0c;不过如果不想麻烦的话叠波还是一个不错的选择&#xff1a;整体效果如下&#xff0c;已经非常形似 直接上链接&#xff1a;Shader - Shadertoy BETA float radiusScale 0.9; float variation(vec2 v1, vec2 v2, float …
阅读更多...
据说这是最细滴，Python接口自动化测试数据驱动DDT使用实战，有这一篇就完全足够了

据说这是最细滴，Python接口自动化测试数据驱动DDT使用实战，有这一篇就完全足够了

前言 环境准备 首先&#xff0c;需要安装ddt模块 pip install ddt调用时标准格式 在类下面如下写上&#xff1a;ddt.ddt 在调用的方法下面需要写上&#xff1a;ddt.data(需要传入的多组数据) DDT简单介绍 名称&#xff1a; Data-Driven Tests&#xff0c;数据驱动测试。 作用…
阅读更多...
深入理解Servlet

深入理解Servlet

目录&#xff1a; ServletWeb开发历史Servlet简介Servlet技术特点Servlet在应用程序中的位置Tomcat运行过程Servlet继承结构Servlet生命周期Servlet处理请求的原理Servlet的作用HttpServletRequest对象HttpServletResponse对象ServletContext对象ServletConfig对象Cookie对象与…
阅读更多...
Keepalived实验

Keepalived实验

一、 LVSKeepalived 实验&#xff1a;7-1为主&#xff1b; 7-2为备&#xff1b; 7-3和7-4为后端服务器 1.关闭防火墙和selinux [rootlocalhost ~]# systemctl stop firewalld [rootlocalhost ~]# setenforce 02.配置主设备7-1 1.安装ipvsadm和keepalived [rootlocalhost ~]#…
阅读更多...
阿珊解说Vue中`$route`和`$router`的区别

阿珊解说Vue中`$route`和`$router`的区别

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站