C++初阶------------------入门C++

作者前言

🎂 ✨✨✨✨✨✨🍧🍧🍧🍧🍧🍧🍧🎂
​🎂 作者介绍： 🎂🎂
🎂 🎉🎉🎉🎉🎉🎉🎉 🎂
🎂作者id：老秦包你会， 🎂
简单介绍：🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂
喜欢学习C语言、C++和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂
🎂个人主页::小小页面🎂
🎂gitee页面:秦大大🎂
🎂🎂🎂🎂🎂🎂🎂🎂
🎂 一个爱分享的小博主 欢迎小可爱们前来借鉴🎂

C++入门引入

  • **作者前言**
  • 命名空间(namespace)
      • ::
    • 命名空间里面嵌套命名空间
    • 命名空间的合并
  • 第一个c++代码
  • 缺省参数
  • 函数重载
    • 为啥c++支持函数重载,而C语言不行
  • 引用
    • 引用的好处
      • 传参
      • 返回值
      • 常引用
    • 指针和引用的区别
    • 内联函数
    • auto
    • 范围的for循环
    • 指针空值nullptr

命名空间(namespace)

在我们学习C语言的过程中，如果我们命名一些和库函数名字相同的变量或者函数，VS编译器就会报错,怎么解决这个问题呢?C++语言就推出了一个关键字
namespace
这个关键字的作用就是解决命名冲突的
未使用关键字:

#include<stdio.h>
#include<stdlib.h>
int rand = 0;
int main()
{printf("%d", rand);return 0;
}

在这里插入图片描述
是会报错的,因为命名和库函数rand冲突了,我们在后面写的代码越多,就越容易命名冲突,
使用关键字:

#include<stdio.h>
#include<stdlib.h>
namespace ncon
{int rand = 0;
}
int main()
{printf("%d", ncon::rand);return 0;
}

在这里插入图片描述

::

这个符号叫域作用限定符
就是告诉VS编译器rand这个变量要在ncon命名的空间里面找,否则是找不到这个rand的
在命名空间里面可以定义函数、结构体、变量、枚举…等,

#include<stdio.h>
#include<stdlib.h>
namespace ncon
{int rand = 0;int Add(int a, int b){return a + b;}typedef struct numnam{int a;int b;}numname;
}
int main()
{printf("%d ", ncon::rand);int count = ncon::Add(1, 2);printf("%d ", count);struct ncon::numnam num = { 10,20 };printf("%d %d", num.a, num.b);return 0;
}

注意一下,结构体的写法是struct关键字在 最前面

命名空间里面嵌套命名空间

#include<stdio.h>
#include<stdlib.h>
namespace ncon
{namespace con{int nums = 10;}
}
int main()
{printf("%d ",ncon::con::nums);return 0;
}

命名空间可以嵌套命名空间,无限套娃

命名空间的合并

我们在一个源文件中可以多个位置命名空间相同的名字,是不会冲突的,会合并成一个命名空间
头文件:

#include<stdio.h>
#include<stdlib.h>
namespace ncon
{typedef struct numnam{int a;int b;}numname;
}

目标文件.c

#include"day1_1.h"
using namespace ncon;
namespace ncon
{int Add(int a, int b){return a + b;}
}
int main()
{int count = Add(1, 2);printf("%d ", count);struct ncon::numnam num = { 10,20 };printf("%d %d ", num.a, num.b);return 0;
}

有人就会发现下面这句代码

using namespace ncon;

这句代码想表达的意思就是
这行代码是C++中的语法，意思是引入命名空间 ncon 中的所有内容，使得在代码中可以直接使用该命名空间中的成员而不需要加上前缀
注意:这种方式不提倡,特别是在项目里会造成不必要的麻烦,所以日常练习可以展开
std:是C++官方库定义的命名空间
但是有时候真的很麻烦,会写很多不必要的前缀
所以我们可以指定展开

using std::cout;
using std::endl;

第一个c++代码

#include<iostream>
int main()
{std::cout << "hello world";printf("hello world");return 0;
}

<< : 流插入

如果要写入一些标识符,如\n

#include<iostream>
int main()
{std::cout << "hello world\n" << "hello " << "11111 " << "\n";printf("hello world");return 0;
}

可以写多个 << 进行拼接
但是一般不会这样写,会写成是std::endl

#include<iostream>
int main()
{std::cout << "hello world"  << std::endl << "hello " << "11111 " << std::endl;printf("hello world");return 0;
}

​<< :流提取

#include<iostream>
using std::cout;
using std::endl;
using std::cin;int main()
{int a = 10;int b = 20;cin >> a >> b;cout << a << endl << b;return 0;
}

在这里插入图片描述
std:: cin :输入
std::cout : 输出

缺省参数

我们知道在C语言中，函数的有参数就必须传参，不传参就会报错，为了解决这个问题，c++就有了可以拥有默认参数的函数

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
namespace ncon
{void Func(int a = 10){cout << a << endl;}void Func1(int a = 10, int b = 20, int c = 100){cout << a << endl;cout << b << endl;cout << c << endl;}
}
using namespace ncon;
int main()
{ncon::Func();ncon::Func(30);Func1();Func1(100);Func1(1,1,1);return 0;

需要注意的是缺省值只能从右往左给，必须是连续给
还有一些是半缺省的函数

void Func(int a, int b = 10, int c = 20){cout<<"a = "<<a<<endl;cout<<"b = "<<b<<endl;cout<<"c = "<<c<<endl;}

半缺省参数必须从右往左依次来给出，不能间隔着给

声明和定义不能同时给参数，只能在声明的时候给。这个是一个默认规定
在头文件中
在这里插入图片描述

缺省值必须是常量或者全局变量

函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
不同的问题。

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
//参数类型不同
int Add(int a, int b)
{return a + b;
}
double Add(double a, double b)
{return a + b;
}
//参数个数不同
void Fun()
{cout << "Fun()" << endl;
}
void Fun(int a)
{cout << "Fun(int a)" << endl;
}
// 参数的顺序不同
void f(int a, double b)
{cout << a << endl;cout << b << endl;
}
void f(double b,int a)
{cout << a << endl;cout << b << endl;
}
int main()
{Add(1, 2);Add(1.1, 2.2);Fun();Fun(6);f(1, 2.2);f(2.2, 6);return 0;
}

参数类型不同
参数个数不同
参数的顺序不同

为啥c++支持函数重载,而C语言不行

我们前面学习过C语言的编译链接，
第一步是预处理 ：主要进行头文件的展开、宏替换、条件编译（#define 、 #if #endif）以及去掉注释等
生成.i文件
第二步编译：生成汇编代码（主要）或者语法错误
在这里插入图片描述
生成.s文件

第三步 汇编:转换成二进制的机器码
生成.o文件(Linux环境下) (在windows是obj文件)

第四步 链接: 合并到一起,链接一些没有确定函数地址、符号表的合并和重定义

C语言不能函数重载的原因:,因为C语言在链接的时候就是使用函数名去找(C语言不存在同名函数),而c++不能使用函数名去找

objdump -S test1c#test1c是一个.out文件

在Linux中C语言函数的调用是通过函数名去找对应的函数找到对应的地址
在这里插入图片描述
而在c++ 中

g++ test1.c -o test1cppobjdump -S test1cpp

在这里插入图片描述
为啥这里的会这么奇怪,这个函数调用的名字 是由Linux的函数名修饰规则决定的,
_Z3Adddd
写法为:
_Z + 函数名的字符个数 + 函数名 + 每个参数的第一个字符(int a 就取i)

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修
饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
int main()
{int a = 0;int b = a;int& c = a;c = 2;return 0;
}
int& c = a;//引用a

int& :引用类型

引用我们可以看作是取别名,改变c或者改变a 都会改变值,而b是一个变量,存储a的值,改变a或者b都不会改变对方
在这里插入图片描述

在这里插入图片描述

引用的好处

传参

前面我们学习过C语言如果要改变变量的值,要传地址
C语言版:

int exchang(int* a, int* b)
{int temp = *a;*a = *b;*b = temp;
}

c++版:

int exchang(int& left, int& right)
{int temp = left;left = right;right = temp;return left;
}

引用的注意:

  1. 引用的时候必须初始化
  2. 引用的指向是唯一的,指定了就不能更改,所以说引用和指针是不能相互取代的
  3. 一个对象可以有多个引用,但是一个引用不能拥有多个对象
  4. 引用参数比直接传参的效率要高,引用参数和传地址参数的效率相似
    以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直
    接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效
    率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
#include<iostream>
#include<time.h>
using std::cout;
using std::endl;
using std::cin;
void Fun1(int& a)
{}
void Fun(int a)
{}
int main()
{int a = 12;int b = a;int i = 0;int begin1 = clock();for(i = 0; i < 1000000; i++)Fun1(a);int end1 = clock();int begin2 = clock();for (i = 0; i < 1000000; i++)Fun(a);int end2 = clock();cout << end1 - begin1 << endl;cout << end2 - begin2 << endl;return 0;
}

在这里插入图片描述

返回值

在C语言中我们返回一个函数的值的时候,不是返回这个变量

int exchang(int a, int b)
{int temp = a;a = *b;b = temp;return a;
}

我们知道函数栈帧的创建和销毁,知道返回值是存在寄存器里面返回的

而在c++中

int& exchang(int left, int right)
{int temp = left;left = right;right = temp;return left;
}

返回的是left的引用,因为left在函数结束的时候就销毁了,所以返回的值是随机值,这样写是错误的写法，前面我们学习过递归的实现，空间是可以重复利用的，

#include<iostream>
#include<time.h>
using std::cout;
using std::endl;
using std::cin;
int& Fun(int a)
{int c = a;c++;return c;
}
int main()
{int& num1 = Fun(6);cout << num1 << endl;cout << num1 << endl;Fun(1000);cout << num1 << endl;return 0;
}

在这里插入图片描述

这个代码可以看出来，num1引用的是c的原来的地址，函数结束，c销毁，但是那块内存还是存在，每次再调用，就会进行重复利用这块空间

正确的写法：
使用静态变量
前面我们知道如果使用静态变量的话，在静态区创建，而不是在栈区创建，这样就可以在函数销毁的时候静态变量不进行空间的释放

#include<iostream>
#include<time.h>
using std::cout;
using std::endl;
using std::cin;
int& Fun(int a)
{static int c = a;c++;return c;
}
int main()
{int& num1 = Fun(6);cout << num1 << endl;cout << num1 << endl;Fun(1000);cout << num1 << endl;return 0;
}

在这里插入图片描述
静态变量只初始化一次

某些场景

#include<iostream>
#include<time.h>
#include<assert.h>
using std::cout;
using std::endl;
using std::cin;
typedef struct Seqlist
{int a[100];int size;
}SL;
void SLModify(SL *ps, int pos, int x)
{assert(ps);assert(ps->size > pos);ps->a[pos] = x;
}int& SLModify(SL* ps, int pos)
{assert(ps);assert(ps->size > pos);return ps->a[pos];
}int main()
{SL lis = { {0},100 };int i = 0;for (i = 0; i < lis.size; i++){SLModify(&lis, i)++;}return 0;
}

这里创建一个顺序表，如果要进行顺序表的每个元素进行加1，有两种方法，要么传地址，要么引用出来

常引用

这里介绍一下

const int a = 10;

这个 在c++中是常量，在C语言中是常变量

#include<iostream>
#include<time.h>
#include<assert.h>
using std::cout;
using std::endl;
using std::cin;int main()
{//引用权限不能放大const int a = 10;//int& b = a;错误的const int& b = a;//权限可以缩小int c = 20;const int& d = c;const int& f = 10;return 0;
}

在常数中，如果对常数进行引用，就不会随便的放大权限，常数不能更改，所以对应引用也不能更改，

常性

当我们如果使用使用不同的引用类型去引用一些不同类型的变量
如

int i = 10;
double j = i;
const double& rj = i;

如果是使用 double&就会报错，为啥？ 因为我们在使用不同类型进行接收的时候，i会产生一个临时变量，（类型转变才会产生临时变量）并且这个临时变量具有常性，需要用const的变量进行接收。

指针和引用的区别

引用：

  1. 语法上，没有开辟空间，在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
  2. 引用比指针使用起来相对更安全
  3. 没有NULL引用，但有NULL指针
  4. 有多级指针，但是没有多级引用
  5. . 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
    位平台下占4个字节)
#include<iostream>
#include<time.h>
#include<assert.h>
using std::cout;
using std::endl;
using std::cin;int main()
{int c = 20;const int& d = c;cout << sizeof(d);return 0;
}

在这里插入图片描述
6. 指针语法上，开辟了空间，在底层实现上实际也是有空间的
7. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

两者共同点：
1.引用的底层是汇编实现的

引用表面好像是传值，其本质也是传地址，只是这个工作有编
译器来做

内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调
用建立栈帧的开销，内联函数提升程序运行的效率。

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
int Add(int a, int b)
{return a + b;
}
int main()
{Add(1, 2);return 0;
}

这里是没有inline修饰，需要创建函数栈帧
在这里插入图片描述
在这里插入图片描述
使用inline修饰

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
inline int Add(int a, int b)
{int c = a + b;return c;
}
int main()
{Add(1, 2);return 0;
}

未显示展开
在这里插入图片描述

要想看到展开我们需要以下操作
在这里插入图片描述
在这里插入图片描述
内联函数 优点：

  1. 可以调试
  2. 效率高，会展开
  3. 不用创建栈帧，提高效率

缺点：
不适合于大型的函数，每次调用inline修饰过的函数，就会展开一次，如果函数有100行，调用10000次，合计就要运行100 * 10000行，没有inline修饰的函数，每调用一次，就会找到相同的函数栈帧进行调用，总次数就是 100（函数的行数） + 10000（反汇编的call），所以inline修饰大型函数就会影响可执行程序的大小

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。（简单的理解，看编译器的心情来决定展不展开）

需要注意的是，如果在其他cpp文件使用inline修饰函数，再到头文件声明，在其他cpp文件使用这个函数就会报错，因为使用inline修饰的函数在链接时不会生成符号表。这是因为inline函数在编译时会被直接插入到调用它的地方，而不会产生独立的函数代码。
day1_1.cpp

#include"day1_1.h"
int main()
{fun(10);return 0;
}

day1_2.cpp

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
inline void fun(int a)
{cout << a << endl;
}

day_1.h

#include<iostream>
using std::cout;
using std::endl;
using std::cin;inline void fun(int a);

在这里插入图片描述
所以我们使用inline修饰函数，在对当前cpp文件或者在头文件定义和声明就行了

auto

auto关键字可以用于自动推导变量的类型，让编译器根据变量的初始化表达式推导出其类型，从而简化代码书写

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
int main()
{int a = 10;int* b = NULL;auto c = a;auto& d = a;cout << typeid(a).name() << endl;cout << typeid(b).name() << endl;cout << typeid(c).name() << endl;cout << typeid(d).name() << endl;return 0;
}

在这里插入图片描述

这里typeid(a).name()是返回a的类型

我们可以得出结论

  1. auto 必须初始化
  2. auto 不能当函数参数,返回值也不行
  3. auto不能声明数组

范围的for循环

与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
前面我们学习过C语言的for循环语句,

int i = 0;
for (i = 0; i < 100; i++)
{printf("%d ", i);
}

但是在c++中的for语句有点差别

#include<iostream>
using std::cout;
using std::endl;
using std::cin;int main()
{int a[] = { 1,2,3,4,5,6,7,8,9 };for (auto e : a){cout << e << " ";}return 0;
}

意思就是遍历一遍a数组,每个元素都依次赋值给e,自动判断结束, 修改e不会修改里面的元素

如果我们要修改元素的值

#include<iostream>
using std::cout;
using std::endl;
using std::cin;int main()
{int a[] = { 1,2,3,4,5,6,7,8,9 };for (auto& e : a){e++;cout << e << " ";}return 0;
}

我们可以使用引用来进行修改

指针空值nullptr

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
void func(int)
{cout << "f(int)" << endl;
}
void func(int*)
{cout << "f(int*)" << endl;
}
int main()
{func(0);func(NULL);return 0;
}

在这里插入图片描述

这里的函数只写了类型,没有写变量,这个在c++是可以的,
看到结果的人可能会发现,为啥都打印了f(int),NULL不是指针类型吗,
其实不是,在c++
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
在这里插入图片描述
如果是c++就是把NULL定义成了一个宏,C语言就是一个指针类型

所以c++就为了弥补这个错误,就写出了一个nullptr来代表NULL空指针
注意：

  1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入
    的。
  2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
  3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

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

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

相关文章

带大家做一个，易上手的家常糖醋白菜

带大家做一个，易上手的家常糖醋白菜

准备 如果是大白菜就一个 小白菜就要两个 因为白菜炒完之后会变少 将白菜叶剥开每叶分成三个小块 整个剥完之后 放入盆中清洗干净 调一个糖醋汁 一勺料酒 两勺生抽 三勺白砂糖 四勺香醋 起锅烧油 放两个干辣椒 辣椒炒一下 然后倒入白菜 翻炒直到油全部融入白菜 然后倒入…
阅读更多...
Windows本地如何部署Apache服务器搭配内网穿透实现无公网IP远程访问？

Windows本地如何部署Apache服务器搭配内网穿透实现无公网IP远程访问？

文章目录 前言1.Apache服务安装配置1.1 进入官网下载安装包1.2 Apache服务配置 2.安装cpolar内网穿透2.1 注册cpolar账号2.2 下载cpolar客户端 3. 获取远程桌面公网地址3.1 登录cpolar web ui管理界面3.2 创建公网地址 4. 固定公网地址 前言 Apache作为全球使用较高的Web服务器…
阅读更多...
自然语言处理1——探索自然语言处理的基础 - Python入门篇

自然语言处理1——探索自然语言处理的基础 - Python入门篇

目录 写在开头1. 介绍自然语言处理的基本概念1.1 NLP的核心目标1.2 常见的NLP任务1.3 应用场景详细介绍1.3.1 医疗保健1.3.2 金融领域1.3.3 教育领域1.3.4 社交媒体分析 2. Python中常用的自然语言处理库简介2.1 NLTK (Natural Language Toolkit)2.2 Spacy2.3 Transformers2.4 …
阅读更多...
张量操作与线性回归

张量操作与线性回归

一、张量的操作&#xff1a;拼接、切分、索引和变换 &#xff08;1&#xff09;张量拼接与切分 1.1 torch.cat() 功能&#xff1a;将张量按维度dim进行拼接 • tensors: 张量序列 • dim : 要拼接的维度 torch.cat(tensors, dim0, outNone)函数用于沿着指定维度dim将多个张量…
阅读更多...
ES6之生成器(Generator)

ES6之生成器(Generator)

✨ 专栏介绍 在现代Web开发中&#xff0c;JavaScript已经成为了不可或缺的一部分。它不仅可以为网页增加交互性和动态性&#xff0c;还可以在后端开发中使用Node.js构建高效的服务器端应用程序。作为一种灵活且易学的脚本语言&#xff0c;JavaScript具有广泛的应用场景&#x…
阅读更多...
复兴计划01-lc06

复兴计划01-lc06

StringBuilder和StringBuffer的区别 1. StringBuffer和StringBuilder都是用于字符串动态拼接,但是StringBuffer拼接的函数方法的实现中用了synchornized上锁&#xff0c;效率较低&#xff0c;不过可以用于多线程以此来维护线程安全&#xff1b;相比之下&#xff0c;StringBuil…
阅读更多...
理解SQL中not in 与null值的真实含义

理解SQL中not in 与null值的真实含义

A not in B的原理是拿A表值与B表值做是否不等的比较, 也就是a ! b. 在sql中, null是缺失未知值而不是空值。 当你判断任意值a ! null时, 官方说, “You cannot use arithmetic comparison operators such as , <, or <> to test for NULL”, 任何与null值的对比都将返…
阅读更多...
Postman使用

Postman使用

Postman使用 Pre-request Script 参考&#xff1a; Scripting in Postman 可以请求、集合或文件夹中添加Pre-request Script&#xff0c;在请求运行之前执行JavaScript 如设置变量值、参数、Header和正文数据&#xff0c;也可以使用Pre-request Script来调试代码&#xff0…
阅读更多...
jupyter notebook打开其他盘的文件

jupyter notebook打开其他盘的文件

jupyter notebook打开其他盘文件 打开jupyter notebook打开terminal输入&#xff1a;jupyter-notebook 路径打开你想打开的工程的文件 打开jupyter notebook 打开terminal 输入&#xff1a;jupyter-notebook 路径 打开你想打开的工程的文件
阅读更多...
TDD-LTE 寻呼流程

TDD-LTE 寻呼流程

目录 1. 寻呼成功流程 1.1 空闲态寻呼 1.2 连接态寻呼 2. 寻呼失败流程 2.1 Paging消息不可达 2.2 RRC建立失败 2.3 eNodeB未上发Initial UE message或达到超时 1. 寻呼成功流程 1.1 空闲态寻呼 寻呼成功&#xff1a;MME发起寻呼&#xff08;S1 接口发送Paing 消息&…
阅读更多...
【docker实战】安装tomcat并连接mysql数据库

【docker实战】安装tomcat并连接mysql数据库

本节用docker来安装tomcat&#xff0c;并用这个tomcat连接我们上一节安装好的mysql数据库 一、拉取镜像 我们安装8.5.69版本 先搜索一下 [rootlocalhost ~]# docker search tomcat NAME DESCRIPTION …
阅读更多...
SpringBoot快速集成多数据源(自动版)

SpringBoot快速集成多数据源(自动版)

有些人因为看见所以相信&#xff0c;有些人因为相信所以看见 有目录&#xff0c;不迷路 前期准备实现演示参考 最近研究了一下多数据源&#xff0c;这篇博客讲的是简单模式&#xff0c;下篇博客预计写自动切换模式 前期准备 本篇博客基于SpringBoot整合MyBatis-plus&#xff0…
阅读更多...
【办公软件】Excel双坐标轴图表

【办公软件】Excel双坐标轴图表

在工作中整理测试数据&#xff0c;往往需要一个图表展示两个差异较大的指标。比如共有三个数据&#xff0c;其中两个是要进行对比的温度值&#xff0c;另一个指标是两个温度的差值&#xff0c;这个差值可能很小。 举个实际的例子&#xff1a;数据如下所示&#xff0c;NTC检测温…
阅读更多...
Qt高质量的开源项目合集

Qt高质量的开源项目合集

文章目录 1.Qt官网下载/文档2.第三方开源 1.Qt官网下载/文档 Qt Downloads Qt 清华大学开源软件镜像站 Qt 官方博客 2.第三方开源 记录了平常项目开发中用到的第三方库&#xff0c;以及一些值得参考的项目&#xff01; Qt AV 基于Qt和FFmpeg的跨平台高性能音视频播放框…
阅读更多...
SQL性能优化-索引

SQL性能优化-索引

1.性能下降sql慢执行时间长等待时间长常见原因 1&#xff09;索引失效 索引分为单索、复合索引。 四种创建索引方式 create index index_name on user (name); create index index_name_2 on user(id,name,email); 2&#xff09;查询语句较烂 3&#xff09;关联查询太多join&a…
阅读更多...
计算机组成原理 数据的表示与运算

计算机组成原理 数据的表示与运算

文章目录 数据的表示与运算数据表示定点数的表示与运算定点数的表示无符号数有符号数定点整数定点小数四码反码补码移码 总结 定点数的运算算术移位原码反码补码总结 逻辑位移循环位移总结 加减运算原码加减法补码加减法 溢出判断采用一位符号位 浮点数的表示与运算表示IEEE 75…
阅读更多...
使用拉普拉斯算子的图像锐化的python代码实现——数字图像处理

使用拉普拉斯算子的图像锐化的python代码实现——数字图像处理

原理 拉普拉斯算子是一个二阶导数算子&#xff0c;用于图像处理中的边缘检测。它通过计算图像亮度的二阶空间导数来工作&#xff0c;能够突出显示图像中的快速变化区域&#xff0c;如边缘。 图像锐化的原理&#xff1a; 图像锐化是指增强图像中的边缘和细节&#xff0c;使图像…
阅读更多...
Linux：apache优化（7）—— 日志分割|日志合并

Linux：apache优化（7）—— 日志分割|日志合并

作用&#xff1a;随着网站访问量的增加&#xff0c;访问日志中的信息会越来越多&#xff0c; Apache 默认访问日志access_log单个文件会越来越大&#xff0c;日志文件体积越大&#xff0c;信息都在一个文件中&#xff0c;查看及分析信息会及不方便。 分割 实现方式&#xff1a…
阅读更多...
Linux操作系统极速入门[常用指令]

Linux操作系统极速入门[常用指令]

linux概述&#xff1a; Linux是一套免费使用和自由传播的操作系统 我们为什么要学&#xff0c;Linux&#xff1f; 主流操作系统&#xff1a; linux系统版本&#xff1a; 内核版&#xff1a; 由linux核心团队开发&#xff0c;维护 免费&#xff0c;开源 负责控制硬件 发行版&…
阅读更多...
如何在MAC OS中的XCODE下添加 ＜bits/stdc++.h＞

如何在MAC OS中的XCODE下添加 ＜bits/stdc++.h＞

mac上使用的编译器是Clang&#xff0c;但是没有万能头文件bits/stdc.h\&#xff0c;本文介绍如何添加万能头文件 Xcode 版本&#xff1a;15.1 - 打开应用程序-Xcode-右键显示包内容 Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/includ…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023