C++ 疑难点

C++疑难点

this指针

调用成员函数时，成员函数通过一个名为 this 的隐式参数来访问调用它的那个对象，用请求该函数的对象地址初始化 this ，this 的指向总是自己这个对象，所以 this 是一个常量指针

Box* get_address()   //得到this的地址
{return this;
}
Box* get_address()   //得到this的地址
{Box box;this = &box; // error: lvalue required as left operand of assignmentreturn this;
}

友元函数和运算符重载

#include <iostream>
#include <cmath>
using namespace std;class MyInteger
{
public:MyInteger() { this->num_ = 0; }MyInteger(int num) : num_(num) {}MyInteger operator+(const MyInteger &other){MyInteger temp;temp.num_ = this->num_ + other.num_;// this->num_ += m.num_; 		// 这违反了加法运算符的语义，加法运算通常是创建一个新的对象来保存结果，而不是改变原始对象。return temp;}MyInteger operator+(const int &other) // 运算符重载{MyInteger temp;temp.num_ = this->num_ + other;return temp;}MyInteger operator+=(const MyInteger &other){MyInteger temp;temp.num_ = this->num_ + other.num_;return temp;}MyInteger operator+=(const int &other){MyInteger temp;temp.num_ = this->num_ + other;return temp;}MyInteger &operator++(){++num_;return *this;}MyInteger operator++(int){MyInteger temp(*this);num_++;return temp;}MyInteger &operator=(const MyInteger &myInteger) // 注意深浅拷贝问题{num_ = myInteger.num_;}friend ostream &operator<<(ostream &out, const MyInteger &myInteger); // 重载左移运算符 没加 const ，cout << m++;报错private:int num_;
};ostream &operator<<(ostream &out, const MyInteger &myInteger)
{out << myInteger.num_;return out;
}void test01()
{MyInteger m;MyInteger m1(10);m1 = m + m1;cout << m << endl;cout << m1 << endl;
}void test02()
{MyInteger m(1);MyInteger m1(100);m = m1 + m;m1 += 10;cout << m << " " << m1 << endl;
}void test03()
{MyInteger m(2);MyInteger m1(8);// cout << ++(++m) << " " << ++m1 << endl;// cout << m << " ";cout << m++;cout << m;
}int main()
{// test01();// test02();test03();// int a=1;// int b=2;// a=a+b;// cout<<a<<" "<<b<<endl;int c = 1;cout << endl;cout << c++ << endl;cout << c << endl;return 0;
}

不能重载的运算符

.，:: ，?:，sizeof，typeid，.* 这几个运算符不能被重载

C++编译器至少给一个类提供四个函数

1、构造函数

2、析构函数

3、拷贝构造函数

4、operator= 函数

多态的实现

多态实现的前提三个条件

1、必须是共有继承

2、通过基类指针指向派生类，并且访问派生类重写的方法。

3、基类中的被重写的方法是虚函数

这种技术让父类指针有多种形态，是一种泛型技术，直到运行时才决定执行哪个版本的函数。所谓泛型技术，就是使用不变的代码来实现可变的算法。多态中没有重写的函数是没有意义的。

水能载舟，亦能覆舟。多态也涉及了安全性的问题，

首先是无法访问子类中自己的虚函数，如Base * base=new Derived(); base->f1();编译时不会通过的（其中f1()是子类自己的虚函数，父类没有）；

然后是如果父类中虚函数是private或者protected，这些函数依旧会存在于虚函数表中，可以通过多态的方式来访问。

#include <iostream>
using namespace std;
class Father
{
public:virtual void f(){cout<<"hello Father!"<<endl;}
};class Son : public Father
{
public:void f(){cout << "hello Son!"<<endl;}
};int main() {Son s;Father *p = &s;p->f();Father f;p=&f;p->f();return 0;
}

菱形继承的问题

继承关系画成图像一个菱形，所以就叫做菱形继承，采用虚继承来解决二义性问题。

虚析构

总的来说是为了避免内存泄漏，当子类中有指针成员变量时才会使用到。也就是说，虚析构函数使得删除指向子类的父类指针时，不仅可以调用父类的的析构函数，也会调用子类的析构函数，这样就可以释放子类指针成员变量在堆中的内存，达到防止内存泄漏的目的。

#include <bits/stdc++.h>
using namespace std;
class CA
{
public:CA() { cout << "CA" << endl; }virtual void f1(){cout << "CA::f1( )" << endl;// f2();}void f2(){cout << "CA::f2( )" << endl;}virtual ~CA(){cout << "~CA" << endl;}
};
class CB : public CA
{
public:CB() { cout << "CB" << endl; }virtual void f1(){cout << "CB::f1( )" << endl;}void f2(){cout << "CB::f2( )" << endl;}virtual ~CB(){cout << "~CB" << endl;}
};
class CC : public CB
{
public:CC() { cout << "CC" << endl; }void f1(){cout<<"CC:f1()"<<endl;}void f2(){cout << "CC:f2()" << endl;}virtual ~CC(){cout << "~CC" << endl;}
};
int main()
{CA *pA = new CC();pA->f1();delete pA;CA *pA1 = new CB();pA1->f1();delete pA;return 0;
}//注意看构造和析构的顺序，正好是相反的

g++和gcc的区别

面试的时候，问到了gcc和g++的区别，没答上来：

首先说明：gcc 和 GCC 是两个不同的东西

GCC:GNU Compiler Collection(GNU 编译器集合)，它可以编译C、C++、JAV、Fortran、Pascal、Object-C、Ada等语言。

gcc是GCC中的GNU C Compiler（C 编译器）

g++是GCC中的GNU C++ Compiler（C++编译器）

​ 一个有趣的事实就是，就本质而言，gcc和g++并不是编译器，也不是编译器的集合，它们只是一种驱动器，根据参数中要编译的文件的类型，调用对应的GUN编译器而已，比如，用gcc编译一个c文件的话，会有以下几个步骤：

​ Step1：Call a preprocessor, like cpp.

​ Step2：Call an actual compiler, like cc or cc1.

​ Step3：Call an assembler, like as.

​ Step4：Call a linker, like ld

​ 由于编译器是可以更换的，所以gcc不仅仅可以编译C文件

​ 所以，更准确的说法是：gcc调用了C compiler，而g++调用了C++ compiler

​ gcc和g++的主要区别：

  1. 对于 .c和.cpp文件，gcc分别当做c和cpp文件编译（c和cpp的语法强度是不一样的）

  2. 对于 .c和.cpp文件，g++则统一当做cpp文件编译

  3. 使用g++编译文件时，g++会自动链接标准库STL，而gcc不会自动链接STL

  4. gcc在编译C文件时，可使用的预定义宏是比较少的

  5. gcc在编译cpp文件时/g++在编译c文件和cpp文件时（这时候gcc和g++调用的都是cpp文件的编译器）

关于内联函数

一般是加快程序执行速度，可能减小可执行文件大小，可能增加可执行文件大小。

速度快：当函数体较短时，内敛函数会像宏一样展开，所以执行速度比一般函数要快。但是如果函数体过大，一般的编译器会放弃内联方式，意思就是你使用内联函数，只不过是向编译器提出了一个申请，编译器可以拒绝，这个函数又会像普通函数一样，执行效率也和普通函数一样。

减小可执行文件大小：内联函数适度

增加可执行文件大小：内联函数过多

仿函数

在c++中仿函数（Functor）是一个类或者结构体，重载了函数调用运算符()，它的主要作用是提供一种更加灵活的函数对象，它可以包含状态信息，并且可以被传递给算法或者函数，从而实现定制的行为。比如实现排序准则、查找准则、谓词（就是一个bool返回值的函数）

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;void Print(int val){cout<<val<<" ";}
class Print1
{
public:void operator()(int val){cout<<val<<" ";}
};void test01()
{vector<int> v;v.push_back(6);v.push_back(66);for_each(v.begin(), v.end(), Print1());cout<<endl<<"--------------"<<endl;for_each(v.begin(), v.end(), Print);
}int main()
{test01();return 0;
}

pointer-like-class的作用

pointer-like-class是指类似指针的类，这种类一般用来模拟指针的行为，但是与裸指针相比具有更多的功能和安全性，如智能指针（Smart Pointers）、迭代器（Iterators）。Smart Pointers有std::unique_ptr和std::shared_ptr、std::weak_ptr。

一：结构化程序设计方法

位运算及其运用

判断奇数还是偶数

int a=11;
int b=1;
if(b&a){cout << "is odd" <<endl;
}else{cout<< "is even" <<endl;
}

取出指定的位

int a=0b11101101;
int b=0b1111;
cout << bitset<sizeof(char)*8>(a&b)<<endl;

判断是否为2的整数幂（0b10 0000 & 0b01 1111），结果是0，说明是2的整数幂。

int x = 64;
int y = x - 1;
cout << ((x & y) ? "no" : "yes") << endl;

指针数组与指向数组的指针的概念与使用

a是一个指向含有三个int型数据数组的指针（如有int p[3]; a指向p是可以的 ）

a1是一个函数三个int*型数据的数组（如a1可以初始化为{&b, &c, &d}）;

#include <iostream>
#include <typeinfo>
using namespace std;
#define sz(type) cout<<sizeof(type)<<endl;
int main(){int b=10, c=1, d=2;int (*a)[3];int* a1[3];cout<<typeid(a).name()<<endl;sz(a);sz(a1);sz(a1[0]);sz(*a)sz(a[0][0])return 0;
}

引用的分类与使用

1、初始化，定义引用时需要加&，

int a=1;
int &b=a;//相当于给a取了一个别名

2、作为函数参数传递，c++在函数参数中传递数组时，直接变成了指针，因为如果将数组传递过去需要将值一个一个拷贝过去，增加了函数调用的开销，所以在 C++ 中，我们有了一种比指针更加便捷的传递聚合类型数据的方式，那就是引用（Reference），通过这种方式传过去减少了生成副本的消耗。

void swap(int &a, int &b){int temp=a;a=b;b=temp;
}

3、作为函数返回值来传递，例如重载左移运算符，需要输出多个内容就需要返回引用。

#include <iostream>
#include <typeinfo>
using namespace std;
#define sz(type) cout << sizeof(type) << endl;
int function1(int &aa) // 以返回值的方法返回函数值
{return aa;
}
int &function2(int &aa) // 以引用方式返回函数值
{return aa;
}
int main()
{int a = 10;// 第一种情况，系统生成要返回值的副本（即临时变量）int b = function1(a); // function1()的返回值先储存在一个a的副本中，// 然后再把副本赋值给b// 第二种情况，报错//  function1(a) = 20;// function1()的返回值为临时变量，不能赋值（即不能为左值）// 第三种情况，系统不会生成返回值的副本function2(a) = 20; // OK  此时a的值变成了20cout<<a<<endl;
}

重载左移运算符，返回引用才会连续输出两个值；

#include <iostream>
using namespace std;class Point
{
public:int x_, y_;Point(int x, int y) : x_(x), y_(y) {}friend ostream &operator<<(ostream &os, const Point &p){os << p.x_ << " " << p.y_ << endl;return os;}
};int main()
{Point p(1, 2);cout<<p<<p;return 0;
}

变量的作用域和生命周期

c++的内存主要分为一下几个部分：栈区、堆区、全局区（静态区）、文字常量区、程序代码区。

全局变量

存储在静态内存分配区，整个程序的生命周期都可以使用，其他文件使用关键字extern也可以使用

局部变量

存储在栈区，与函数共存亡

全局静态变量

与全局变量类似，也是存储在静态内存分配区，生命周期与整个程序同在，不过不能再其他文件使用。

局部静态变量

也是存储在静态内存分配区，调用函数后便一直存在，只不过只能在函数内可见。

类型别名与类型推断

1、别名：typedef、using

2、推断：auto、decltype

STL顺序容器

vector：视作可变大小的数组，可随机访问，在非尾部的位置插入比较慢

deque：双端队列，支持随机访问，在头尾位置插入和删除比较快

list：双向链表，支持双向顺序访问（rbegin()、rend()），在 list 任意位置插入和删除都比较快

forward_list：单向链表，只能单向顺序访问，在 forward_list 的任意位置插入和删除都比较快

array：固定大小的数组，支持随机访问，不能添加或者删除元素

string：与 vector 类似，专门保存字符串，随机访问快，在尾部插入和删除快

STL关联容器

map：键值对，一对一，基于红黑树，对关键字进行排序

set：只保存关键字，不重复

multimap：关键字可以重复的 map ，即一对多，如统计数学课的学生成绩

multiset：保存可以重复的关键字

unordered_map：键值对，一对一，基于哈希值，不对键值对进行排序

unordered_set：只保存关键字，不排序

unordered_multimap：键值对，一对多，基于哈希值

unordered_multiset：保存可以重复的关键字，不排序

STL容器适配器

包括：stack、queue、priority_queue

stack 和 queue 基于deque实现， priority_queue 基于 vector 实现

流对象

包括输入流对象（ostream，如std::cin，从键盘读取数据），输出流对象（istream，如std::cout，向屏幕写入数据）

还有文件输入流对象（ifstream，使用 std::ifstream 来创建对象，将数据从文件中读取出来），文件输出流对象（ofstream，使用 std::ofstream 来创建对象，将数据写入文件）

#include <iostream>
#include <fstream>
using namespace std;void test01()
{ofstream file;file.open("text.txt", ios::out);file << "xinm" << endl;file << "namji" << endl;file.close();
}
void test02()
{ifstream ifile;ifile.open("text.txt", ios::in);if(ifile.is_open()){char buf[1024];while(ifile >> buf){cout<< buf<<endl;}}ifile.close();
}int main()
{test02();return 0;
}

使用二进制流读写文件

#include <iostream>
#include <fstream>
using namespace std;
class Person
{
public:// Person(char name[], int age):name_(name), age_(age){}char name_[20];int age_;
};void test01()
{ofstream file;file.open("text.txt", ios::out | ios::binary);Person p = {"hhhhh", 18};file.write((const char *)&p, sizeof(p));file.close();
}
void test02()
{ifstream ifile;ifile.open("text.txt", ios::in | ios::binary);if (ifile.is_open()){// 1// char buf[1024];// while(ifile >> buf)// {//     cout<< buf<<endl;// }// 2// char buf[1024];// while (ifile.getline(buf, sizeof(buf)))// {//     cout << buf << endl;// }// 3// string buf;// while(getline(ifile, buf)){//     cout << buf <<endl;// }Person p;ifile.read((char *)&p, sizeof(p));cout << p.name_ << p.age_ << endl;}ifile.close();
}int main()
{test02();return 0;
}

异常处理的构造和析构函数

若在 try 中抛出异常，在转到 catch 前，会对有关对象进行析构

#include <iostream>using namespace std;//异常处理的构造和析构函数 
class Student{private:string name;int sno;public:Student(string name1,int sno1){name=name1;sno=sno1;} ~Student(){cout<<"Destruct Student:"<<sno<<endl;}void checkSno(){if(sno==0){throw sno;}else{cout<<name<<":"<<sno<<endl; }}
};int main()
{try{Student a("pink",1);a.checkSno();Student b("floyd",0); //构造对象b.checkSno();  //抛出异常跳到catch语句块中}catch(int){cout<<"error:sno=0!"<<endl;}return 0;
}

可以看到上面这段代码的输出结果是先对a、b析构然后再转到catch输出内容。

类模板与继承

要注意继承的时候要加上基类的类型

#include <iostream>using namespace std;template<class T>
class Base
{public:T c;
};template<class T>
class Deri: public Base<T>
{public:T a;
};int main()
{Deri<int> d;d.a=4;d.c=6;cout <<d.Base::c<<endl;// cout << sizeof(Deri<int>)<<endl;return 0;
}

继承时不能被继承的函数

包括：构造函数、拷贝构造函数、析构函数，注意：operator=函数是可以被继承的

#include <iostream>
#include <cstring>
using namespace std;class A{
public:A(){}A(int price, int weight):price_(price), weight_(weight){}A& operator=(const A& a){cout << "operator=1" << endl;}
private:int price_;int weight_;
};class B: public A{
public:B(int price, int weight):price_(price), weight_(weight){}
private:int price_;int weight_;
};int main(){
//	A a1(1,0);
//	A a2;
//	a2=a1;B b1(10,0),b2(2,0);b2=b1;return 0;
}

上面说明operator=函数被继承下去了。

静态数据成员的只能在类外初始化

类内定义，类外初始化一次，然后在整个程序运行期间都可以存在

原因

1、静态成员变量存储在静态存储区域内，在编译阶段就为他们分配内存空间，

2、静态成员变量是类级别的，他在所有类实例中是公有的，如果允许在类内部初始化，就可能导致每个实例都有一个独立的副本

3、这样可以避免多次初始化

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <math.h>
using namespace std;
class Point
{
public:Point(int x, int y) : x_(x), y_(y){}void setX(int val){x_ = val;}void setY(int val){y_ = val;}int getX() const{return x_;}int getY() const{return y_;}private:int x_;int y_;
};
class Circle
{
public:Circle(int x, int y, int r) : center_(x, y), r_(r){num_++;cout << "Circle number: " << getNum() << endl;;}static int getNum(){return num_;}friend double getDistance(const Circle &c1, const Circle &c2);private:static int num_;Point center_;int r_;
};int Circle::num_ = 0;
double getDistance(const Circle &c1, const Circle &c2)
{double x=double(c2.center_.getX()-c1.center_.getX());double y=double(c2.center_.getY()-c1.center_.getY());return sqrt(x*x + y*y);
}void testCircle()
{Circle c1(1, 2, 3);Circle c2(4, 6, 2);cout << getDistance(c1, c2) << endl;
}int main()
{testCircle();return 0;
}

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

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

相关文章

一大波你可能不知道的 Linux 网络工具

一大波你可能不知道的 Linux 网络工具

如果要在你的系统上监控网络&#xff0c;那么使用命令行工具是非常实用的&#xff0c;并且对于 Linux 用户来说&#xff0c;有着许许多多现成的工具可以使用&#xff0c;如&#xff1a;nethogs, ntopng, nload, iftop, iptraf, bmon, slurm, tcptrack, cbm, netwatch, collectl…
阅读更多...
idea：springboot项目搭建

idea：springboot项目搭建

目录 一、创建项目 1、File → New → Project 2、Spring Initializr → Next 3、填写信息 → Next 4、web → Spring Web → Next 5、填写信息 → Finish 6、处理配置不合理内容 7、注意事项 7.1 有依赖包&#xff0c;却显示找不到依赖&#xff0c;刷新一下maven 7.…
阅读更多...
linux系统docker历史以及对虚拟机的区别

linux系统docker历史以及对虚拟机的区别

docker历史及与容器的区别 docker容器历史对paas降维打击容器和虚拟机的区别容器应用场景 docker容器历史 容器概念始于 1979 年提出的 UNIX chroot&#xff0c;它是一个 UNIX 操作系统的系统调用&#xff0c;将一个进程及其子进程的根目录改变到文件系统中的一个新位置&#…
阅读更多...
社交媒体的未来图景：探索Facebook的数字化之旅

社交媒体的未来图景：探索Facebook的数字化之旅

随着科技的迅猛发展&#xff0c;数字化社交已经成为了我们日常生活中不可或缺的一部分。在这个数字化时代&#xff0c;社交媒体平台扮演着重要角色&#xff0c;其中Facebook作为社交媒体的先锋&#xff0c;不断探索创新之路&#xff0c;引领着数字化社交的未来发展。本文将深入…
阅读更多...
CF1520 Round 719 (Div. 3) 补题报告

CF1520 Round 719 (Div. 3) 补题报告

Codeforces Round 719 (Div. 3) A. Do Not Be Distracted! A. 不要分心&#xff01; 题意 给定一个字符串&#xff0c;相同的字母只能相互连接出现&#xff0c;不得出现后再次单独出现&#xff0c;判断字符串是否合规 思路 用桶记录字符出现的次数&#xff0c;判断再次出…
阅读更多...
两天学会微服务网关Gateway-Gateway路由规则

两天学会微服务网关Gateway-Gateway路由规则

锋哥原创的微服务网关Gateway视频教程&#xff1a; Gateway微服务网关视频教程&#xff08;无废话版&#xff09;_哔哩哔哩_bilibiliGateway微服务网关视频教程&#xff08;无废话版&#xff09;共计17条视频&#xff0c;包括&#xff1a;1_Gateway简介、2_Gateway工作原理、3…
阅读更多...
和数软件：区块链技术的爆发与冲击

和数软件：区块链技术的爆发与冲击

什么是区块链&#xff1f;它是如何发展而来的&#xff1f;应用在哪些领域&#xff1f;将会对我国的社会经济产生哪些重大影响&#xff1f; 什么是区块链 区块链作为一种底层技术&#xff0c;最早的实践是数字货币。根据最早的中本聪定义&#xff0c;区块链实质上是一种基于网…
阅读更多...
MS2548 国产自动方向控制、半双工 RS-485 收发器 替代MAX13487

MS2548 国产自动方向控制、半双工 RS-485 收发器 替代MAX13487

MS2548 国产自动方向控制、半双工 RS-485 收发器 替代MAX13487 北京冠宇铭通科技有限公司 肖小姐 产品简述 MS2548 是一个 5V 供电、半双工 RS-485 收发器。 芯片具有自动换向控制功能&#xff0c;可用于隔离485 端口&#xff0c;驱动器输入与使能信号一起配合控制芯片的状态&…
阅读更多...
机器学习--循环神经网络（RNN）4

机器学习--循环神经网络（RNN）4

一、RNN的学习方式 如果要做学习&#xff0c;需要定义一个损失函数&#xff08;loss function&#xff09;来评估模型的好坏&#xff0c;选一个参数要让损失最小。 以槽填充为例&#xff0c;如上图所示&#xff0c;给定一些句子&#xff0c;给定一些标签&#xff0c;告诉机器…
阅读更多...
借助Aspose.html控件，在 Java 中将 URL 转换为 PDF

借助Aspose.html控件，在 Java 中将 URL 转换为 PDF

如果您正在寻找一种将实时 URL 中的网页另存为 PDF文档的方法&#xff0c;那么您来对地方了。在这篇博文中&#xff0c;我们将学习如何使用 Java 将 URL 转换为 PDF。从实时 URL转换HTML网页可以像任何其他文档一样保存所需的网页以供离线访问。将网页保存为 PDF 格式可以轻松突…
阅读更多...
华为ce12800交换机m-lag（V-STP模式）配置举例

华为ce12800交换机m-lag（V-STP模式）配置举例

配置## 标题思路 采用如下的思路配置M-LAG双归接入IP网络&#xff1a; 1.在Switch上配置上行接口绑定在一个Eth-Trunk中。 2.分别在SwitchA和SwitchB上配置V-STP、DFS Group、peer-link和M-LAG接口。 3.分别在SwitchA和SwitchB上配置LACP M-LAG的系统优先级、系统ID。 4.分别在…
阅读更多...
【STM32+HAL】GY25倾斜度角度模块

【STM32+HAL】GY25倾斜度角度模块

一、前言 有关MPU6050模块读取六轴传感器数值的详细内容&#xff0c;详见【STM32HAL】姿态传感器陀螺仪MPU6050模块 二、所用工具 1、芯片&#xff1a;STM32F103C8T6 2、配置软件&#xff1a;CUBEMX 3、编译器&#xff1a;KEIL5 4、产品型号&#xff1a;GY-25 5、使用芯片…
阅读更多...
基于SSH框架的鞋业管理系统设计与实现

基于SSH框架的鞋业管理系统设计与实现

目 录 摘 要 I Abstract II 引 言 1 1 相关技术 3 1.1 MySQL 3 1.2 SSH框架 3 1.2.1 Struts 3 1.2.2 Spring 4 1.2.3 Hibernate 5 1.3 B/S架构 5 1.4 本章小结 6 2 系统分析 7 2.1 用例分析 7 2.2 功能需求 9 2.3 非功能需求 11 2.4 本章小结 12 3 系统设计 13 3.1 系统概要设…
阅读更多...
239. 滑动窗口最大值(leetcoude-hot100)-另附一道同类扩展题

239. 滑动窗口最大值(leetcoude-hot100)-另附一道同类扩展题

239. 滑动窗口最大值 解题思路 本题的主要思想是通过单调队列去存储数组的下标&#xff0c;对于这道题目来讲&#xff0c;是通过一个数组b来维护一个单调递减的队列&#xff0c;用hh和tt来记录数组b所模拟的队列的头部和尾部&#xff0c;而b[i]记录的是数组nums的对应元素的下…
阅读更多...
793.高精度乘法(acwing)

793.高精度乘法(acwing)

文章目录 793.高精度乘法题目描述高精度乘法 793.高精度乘法 题目描述 给定两个正整数A和B&#xff0c;请你计算A * B的值。 输入格式 共两行&#xff0c;第一行包含整数A&#xff0c;第二行包含整数B。 输出格式 共一行&#xff0c;包含A * B的值。 数据范围 1≤A的长度≤…
阅读更多...
BigDecimal可以用equals方法做等值比较吗？

BigDecimal可以用equals方法做等值比较吗？

结论是不可以&#xff0c;BigDecimal的equals方法不仅会比较值&#xff0c;还会比较精度&#xff0c;比如1.0和1.00虽然值是一样的&#xff0c;我们也倾向于认为是相同的&#xff0c;但是因为精度不同&#xff0c;最终得到的结论是false。 代码如下&#xff1a; Test public v…
阅读更多...
Ansible Inventory主机清单和playbook 剧本

Ansible Inventory主机清单和playbook 剧本

Ansible Inventory主机清单playbook 剧本一、inventory主机清单管理1、主机与组2、变量2.1 主机变量2.2 组变量2.3 组嵌套2.4 别名 3、inventory 中的变量 二、Ansible 的脚本 --- playbook 剧本1、playbook的组成2、如何定义playbook &#xff1f;2.1 基本格式2.2 语句的横向/…
阅读更多...
云计算科学与工程实践指南--章节引言收集

云计算科学与工程实践指南--章节引言收集

云计算科学与工程实践指南–章节引言收集 //本文收集 【云计算科学与工程实践指南】 书中每一章节的引言。 我已厌倦了在一本书中阅读云的定义。难道你不失望吗&#xff1f;你正在阅读一个很好的故事&#xff0c;突然间作者必须停下来介绍云。谁在乎云是什么&#xff1f; 通…
阅读更多...
使用 Mendix 中的 OIDC 模块集成 Azure AD SSO

使用 Mendix 中的 OIDC 模块集成 Azure AD SSO

前言 在当今快速发展的数字化世界中&#xff0c;企业追求高效率和灵活性已成为常态。Mendix&#xff0c;作为一个先进的低代码开发平台&#xff0c;正是企业快速响应市场需求、加速数字化转型过程的利器。通过其直观的可视化开发环境&#xff0c;即使是非技术背景的用户也能设…
阅读更多...
SpringBoot-WEB相关

SpringBoot-WEB相关

WEB相关 WebApplicationContextServletContextAwareProcessor用于处理带有WebApplicationContextServletContextAware接口的Bean&#xff0c;该接口的目的是&#xff1a;用于指示 Spring 中的 Bean 希望获取 ServletContext 对象。这个接口不包含任何方法&#xff0c;它仅仅是…
阅读更多...
最新文章

Copyright @ 2022~2023