C语言--数据在内存中的存储

数据在内存中的存储

主要研究整型和浮点型在内存中的存储。

1. 整数在内存中的存储

在学习操作符的时候，就了解过了下面的内容：

整数的2进制表示方法有三种，即原码、反码和补码。

有符号的整数，三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，最高位的一位是被当做符号位，剩余的都是数值位。

正整数的原、反、补码都相同。

负整数的三种表示方法各不相同。

  • 原码：直接将数值按照正负数的形式翻译成二进制得到的就是原码。

  • 反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。

  • 补码：反码+1就得到补码。

整数有原码、反码、补码三种表示方法，但是在内存中的是补码，其中计算用的内存中的二进制，使用的也就是补码。

对于整型来说：数据存放内存中其实存放的是补码。

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。

原因在于，使用补码，可以将符号位和数值域统一处理；

同时，加法和减法也可以统一处理（CPU只有加法器）。此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

2. 大小端字节序和字节序判断

当我们了解了整数在内存中存储后，我们调试看一个细节：

#include <stdio.h>

int main()
{
    int a = 0x11223344;
    
    return 0;
}

一个十六进制位*（8 4 2 1）*等于四个二进制位，所以其中11占一个字节，22占一个字节以此类推。所以11223344总共占了四个字节，将这个四个字节数据存进a中，可以将int类型的a填满。

调试的时候，我们可以看到在a中的 0x11223344 这个数字是按照字节为单位，倒着存储的。这是为什么呢？

补充：有关数据存储的问题只需要保证最终在使用数据时可以将数据拿出来使用就可以，所以只要保证可以拿出数据理论上任何存储方式都是可以的，但是为了保证可以合理的拿出数据进行使用产生的下面两种存储方式。

2.1 什么是大小端？

其实超过一个字节的数据在内存中存储的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下面是具体的概念：（以字节为单位讨论他们的存储顺序的）

  • 大端（存储）模式：（顺着排）
    是指数据的低位字节内容保存在内存的高地址处，而数据的高位字节内容，保存在内存的低地址处。

  • 小端（存储）模式：（逆着排）
    是指数据的低位字节内容保存在内存的低地址处，而数据的高位字节内容，保存在内存的高地址处。

上述概念需要记住，方便辨别大小端。

如上图所示，由于11 为高位字节，并在内存中存放在高位地址中，而且是逆着排的，所以VS中的存储方式是小端（存储）模式。

2.2 为什么有大小端?

为什么会有大小端模式之分呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8位，但是在C语言中除了8位的char之外，还有16位的short型，32位的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

例如：一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

因为内存中的一个内存单元的大小就是一个字节，这时存储超过一个字节的数据，就需要将多个字节的数据切成一个个字节进行存放，所以切开数据就会产生大小端的问题。

2.3 练习

2.3.1 练习1（判断当前机器的字节序）

简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。

//代码1
#include <stdio.h>
int check_sys()
{
    int i = 1;
    return (*(char *)&i);	//返回1是小端模式，返回0是大端存储
}

int main()
{
    int ret = check_sys();
    if(ret == 1)
    {
            printf("小端");
    }
    else
    {
            printf("大端");
    }
    return 0;
}

补充：

  • 这里是int i = 1，实际在内存中存储的方式是0x00 00 00 01，四个字节存储

  • 只需要将四个字节中的第一个字节取出，再判断是00还是01即可判断出存储方式

  • 因为变量i是int类型，如果直接取地址就是int*就会从首地址往后取四个字节，但是只需要对首地址后面的第一个字节进行判断即可，所以可以对i取地址，再强转成char*类型即可实现

  • 在对第一个字节的地址进行解引用，即可取出排列在内存首位的一个字节的数据，即可进行判断

注意：

  1. 这里不直接强制转化成char的原因是，强制转化有其自己的逻辑，他会取出int类型中的四个字节中有效数字，所以无法保证取出的数据的位置，也就没有办法确定存储方式。
2.3.2 练习2（整型提升与占位符%d）
#include <stdio.h>
int main()
{
    char a= -1;
    signed char b=-1;
    unsigned char c=-1;
    printf("a=%d,b=%d,c=%d",a,b,c);
    return 0;
}

运行结果：在这里插入图片描述

说明：

a的打印：

  • 在C语言中char，是否有符号是不确定的，这个取决于编译器，但是大部分编译器char == signed char

  • 由于-1是整型类型， 再赋值给char a时，需要发生一些变化 -1的原码：10000000000000000000000000000001 -1的反码：11111111111111111111111111111110 -1的补码：11111111111111111111111111111111（在内存中存储的形式）

但是因为需要将其放进一个字节的内存空间中去存储，所自然选择第一个字节的8位bit位(11111111)放进char a中

  • 下面的printf语句中的**%d表示打印有符号的整数，%u打印无符号整数**，所以在打印a时需要发生整型提升，这里的s的类型是有符号的char类型，这里的最高位则默认补符号位，所以对其进行整型提升的时候高位补符号位即可。 则最后整型提升的结果是11111111111111111111111111111111

这里整型提升的结果是在内存中的补码，但是打印的时候需要打印原码，随后则对整型提升的补码求其原码 原码为：10000000000000000000000000000001

也就是-1，所以最后打印的结果是a = -1。

**b的打印：**因为VS中char == signed char所以b的打印与a的打印同理。

c的打印：

前面的分析与a的打印一样，但是在进行整型提升的结果产生差异

因为c的类型是unsigned char，在对于无符号的char类型进行整型提升的时候直接在高位补0即可。

最后整型提升的结果是：00000000000000000000000011111111

同时因为是无符号类型，原码反码和补码都一样，在利用printf函数打印的时候直接打印，将二进制转化成十进制为255。

2.3.3 练习3（整型提升与占位符%u）
#include <stdio.h>
int main()
{
    char a = -128;
    printf("%u",a);
    return 0;
}

运行结果：在这里插入图片描述

说明：

  • -128的原码：10000000000000000000000010000000 -128的反码：11111111111111111111111101111111 -128的补码：11111111111111111111111110000000

因为需要将-128这个整数放进char类型的a进行存储，取最低的8位在内存中存储也就是10000000 放进char a中

  • 因为printf函数适用于打印整数，所以需要对char类型的a进行整型提升，因为VS中char == signed char，整型提升需要在高位补上符号位，所以最后整型提升的结果：11111111111111111111111110000000

  • 这里的printf函数利用的占位符是%u，意思是打印无符号整数，以%u的角度认为内存中存储的是无符号整数。 所以对于整型提升之后存放在内存中的数据11111111111111111111111110000000，直接默认为是无符号整数，其原码反码补码都一样，所以直接将其转化成十进制输出为4294987168。

#include <stdio.h>
int main()
{
    char a = 128;
    printf("%u",a);
    return 0;
}

说明：运行结果和分析思路与上面的代码一致

因为char类型的存储范围是-128~127，所以该代码中的a存不下128。

补充：

为什么char类型的存储范围是-128~127

因为VS中char == signed char，所以下面8位数据的首位数据都是符号位，其中1开头的数据转化为十进制，需要将其从反码转化为原码

注意10000000 其不能按照常规的将补码转化为原码的思路计算，因为其反码为11111111，+1后需要进位，所以直接将其翻译为-128

在这里插入图片描述

第二个代码中的128存不下，所以就相当于是往里放了-128，这就是第一个和第二个代码运行结果一样的原因。

为什么unsigned char类型的存储范围是0~255

因为是无符号类型，其中的8位数据都是有效位

在这里插入图片描述

以此类推，short、int等类型的存储范围都可以用这种思路的方式算出。

补充：signed int 和unsigned int 的作用

其实signed int 和unsigned int 都可以在内存中开辟相同的四个字节的空间进行存放数据，只是signed规定最高位为符号位，但是unsigned规定最高位不是符号位，他们都有能力存放相同四个字节的数据，无论数据是否可以存下，他们只负责将对应的数据放进自己的存储空间中，至于如何使用他们存放的数据是程序员自己应该做出的决定。

int main()
{
    signed int num = -10;
    printf("%d",num);
    printf("%u",num);
    return 0;
}

输出结果：在这里插入图片描述

所以根据上述代码，站在%d的角度去解读num中的数据，反映出来的结果就是-10；站在%u的角度去解读num中的数据，反映出来的结果就是4294987168。如何去使用内存中的数据、以怎样的视角去看待存放在内存中的数据是很重要的，与数据是什么类型是否带有符号关系不大。

同样如果将上面的代码中的signed int 改成 unsigned int 输出的结果还是不会改变。

在这里插入图片描述

类型的作用还是像内存申请一块空间，然后将数据放入，所以如何看待内存中的这串数据才是更重要的。

但是代码的编写需要有意义，一般signed int 的变量就用%d打印，unsigned int 就用%u打印。

2.3.4 练习4（类型的范围循环逻辑、测试一个类型的存储范围）
#include <stdio.h>
#include <string.h>

int main()
{
    char a[1000];
    int i;
    for(i=0; i<1000; i++)
    {
        a[i] = -1-i;
    }
    printf("%d",strlen(a));
    return 0;
}

运行结果：255

说明：

  • 上述程序主要是利用for循环不断向char[1000]类型数组a中，从-1开始不断递减的存储进数据。

  • 由于strlen函数的作用是求字符串的长度，统计\0（数值0）之前的字符个数，所以按照正常思路（下图方框中的红色数字）由-1不断递减存入数组a中，所以该数组中没有出现数值0，所以返回值无法计算。

  • 但是因为数组a类型char的限制，结合上面对于类型取值范围的分析，可以知道如果是-1的递减取值的话则是从-1按照圆的逆时针取值放入数组a中（下入方框中的蓝色数字）。

  • 根据计算在第一次放入数值0的时候停止计数，所以返回的就是char类型的空间大小也就是255。

在这里插入图片描述

2.3.5 练习5（类型的范围循环逻辑）
#include <stdio.h>

unsigned char i = 0;//全局变量
int main()
{
    for(i = 0;i<=255;i++)//循环256次
    {
        printf("hello world");
    }
    return 0;
}

运行结果：死循环打印 hello world

说明：

由于i是unsigned char 类型，取值范围为0~255，所以i不会大于255循环条件恒成立，故死循环。

#include <stdio.h>

int main()
{
    unsigned int i;
    for(i = 9; i >= 0; i--)
    {
        printf("%u",i);
    }
    return 0;
}

运行结果：死循环打印数字

说明：

因为i是unsigned int 类型，取值恒大于0，所以循环条件恒成立，故死循环。

但是，当i < 0后，因为需要打印无符号的整数，故会将-1的补码直接当做原码转成十进制打印在屏幕上，故会是一个很大的数字。

2.3.6 练习6（综合练习）
#include <stdio.h>
//X86环境 小端字节序 
int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    
    printf("%x,%x", ptr1[-1], *ptr2);
    //%x 是16进制的形式打印
    return 0;
}

运行结果：4,2000000

说明：

  • 画出如下思考图，得到ptr1，其中因为&a +1的类型是int(*)[4]，但是prl1的类型是int(*)，如果需要二者进行赋值操作则需要进行类型的强制转化；另外&a + 1代表跳过整个数组的地址，并不是只跳过数组中的一个元素。 下面ptr1[-1]等价为*（ptr1-1）由于ptr1是整型指针，-1则相当于地址向低地址偏移4个字节，指向如图位置为0x4，打印出结果为4

在这里插入图片描述

  • 对于ptr2首先对数组名也就是首元素地址强制转化为int类型，在对这个整数+1，运算之后得到的数与起始地址相差一个字节，也就是只向高位偏移1个字节，这时需要了解数组中每个字节的数据情况，画出下面的分布图，注意题目要求按照小端字节存储方式分布。根据图像，（（int）a + 1）表示起始地址向高位偏移1个字节的地址指向01后面的地址，此时对其强制转化成（int*）整型指针；下面printf语句中对ptr2解引用，对整型指针解引用需要访问四个字节（00 00 00 02），同时因为存方式是小端存放，还原成真实值就是02 00 00 00，所以打印结果为2000000

在这里插入图片描述

  • 如果想打印成0x4,0x2000000 可以将占位符%x改成%#x即可。

3. 浮点数在内存中的存储

常见的浮点数：3.14159、1E10（科学计数法）等，浮点数家族包括：float、double、long double类型。

浮点数表示的范围：float.h中定义。

3.1 练习

#include <stdio.h>

int main()
{
    int n = 9;
    float *pFloat = (float *)&n;
    printf("n的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);

    *pFloat = 9.0;
    printf("num的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);
    return 0;
}

运行结果：

n的值为：9 *pFloat的值为：0.000000

n的值为：1091567616 *pFloat的值为：9.000000

说明：

  • 上半部分的代码中，将9以整数的格式存储进整型变量中，再用整数的格式打印可以打印出整数9，但是在以浮点数的格式打印时却不是9.0，这就说明整数和浮点数的存储方式是不一样的，因为以整型的形式放进去看，以浮点型的形式拿出来的结果却不一样。并且在下半部分的代码中，以浮点型的数据放进内存中，在以整型的形式拿出打印的时候打印的却是1091567616，但是以浮点型的形式放入以浮点型的形式拿出却可以正常打印出9.0，结果正确。（整数和浮点数在内存中的存储方式是有区别的）

3.2 浮点数的存储

上面的代码中，num和*pFloat在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？

要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。

根据国际标准IEEE（电气和电子工程协会）754，任意一个二进制浮点数V可以表示成下面的形式：

V = ( − 1 ) S ∗ M ∗ 2 E V = (-1)^S * M * 2^E V=(−1)S∗M∗2E

  • S表示符号位，当S=0，V为正数；当S=1，V为负数；
  • M表示有效数字，M是大于等于1，小于2的；
  • 2 E 2^E 2E表示指数位 。

举例来说：

十进制的5.5，写成二进制是 101.1*（按照位权的概念这里小数点后面的1代表2^-1）*

相当于 1.011 × 2 2 1.011×2^2 1.011×22（在二进制的基础上左移几位，在科学计数法中就在后面乘2的几次方）。

那么，按照上面V的格式，可以写出公式为 ( − 1 ) 0 ∗ 1.011 ∗ 2 2 (-1)^0*1.011*2^2 (−1)0∗1.011∗22，可以得出S = 0，M = 1.011，E = 2

十进制的-5.0，写成二进制是-101.0，相当于- 1.01 × 2 2 1.01×2^2 1.01×22 。那么S = 1，M = 1.01，E = 2。

任何浮点数V都可以化成上述的二进制数，这样只需要存储S、M、E即可

所以浮点数的存储，存储的是S、M、E 相关的值。

IEEE 754规定：

  • 对于32位的浮点数（float类型），最高的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M；
  • 对于64位的浮点数（double类型），最高的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M。

float类型浮点数的分配

在这里插入图片描述

double类型浮点数内存分配

在这里插入图片描述

3.2.1 浮点数存的过程

IEEE 754对有效数字M和指数E，还有一些特别规定。

前面说过，1<M<2, 也就是说，M 可以写成 1.xxxxxxxxx的形式，其中 xxxxxxx表示小数部分。

IEEE754 规定，在计算机内部保存 M 时，默认这个数的第一位总是 1, 因此可以被舍去，只保存后面的xxxxxx 部分。比如保存 1.01 的时候，只保存 01, 等到读取的时时候，再把第一位的 1 加上去。这样做的目的，是节省 1 位有效数字。以 32 位浮点数为例，留给 M 只有有 23 位，将第一位的 1 舍去以后，等于可以保存 24 位有效数字。

至于指数E,情况就比较复杂
首先,E为一个无符号整数(unsigned int)

这意味着，如果 E 为 8 位，它的取值范围为 0~255; 如果 E 为 11 位，它的取值范围为 0~2047。但是，科学计数法中的 E 是可以出现负数的，所以 IEEE754 现定，存入内存时 E 的真实值必须再加上一个中间数，对于 8 位的 E, 这个中间数是 127; 对于 11 位的 E, 这个中间数是 1023。比如，2^10的 E 是10, 所以保存成 32 位浮点数时，必须保存成 10+127=137, 即 10001001。

这里的中间值是为了保证存进内存中的E的数据一定是一个正数。

3.2.2 浮点数取的过程

指数 E 从内存中取出还可以再分成三种情况:

E 不全为 0 或不全为 1（正常情况既有0也有1）

这时，浮点数就采用下面的规则表示，即指数 E 的计算值减去 127 (或 1023), 得到真实值，再将有效数字 M 前加上第一位的 1。

比如：0.5 的二进制形式为 0.1, 由于规定正数部分必须为 1, 即将小数点右移 1 位，则为 1.0*2^(-1), 其阶码为 - 1+127 (中间值)=126, 表示为 01111110, 而尾数 1.0 去掉整数部分为 0, 补齐 0 到 23 位00000000000000000000000, 则其二进制表示形式为:

0 01111110 00000000000000000000000

E 全为 0

这时，浮点数的指数 E 等于 1-127 (或者 1-1023) 即为真实值，有效数字 M 不再加上第一位的 1, 而是还原为 0.xxxxxx 的小数。这样做是为了表示士 0, 以及接近于 0 的很小的数字。

0 00000000 0010000000000000000000

E 全为 1

这时，如果有效数字 M 全为 0, 表示土无穷大 (正负取决于符号位 (s)）

0 11111111 0001000000000000000000

其中，M部分数据的存储是忽略科学技术法的整数部分的1，将后面的小数部分写到M的区域，再用0补齐后面的0~23位。

3.3 题目解析

#include <stdio.h>

int main()
{
    int n = 9;
    float *pFloat = (float *)&n;
    printf("n的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);

    *pFloat = 9.0;
    printf("num的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);
    return 0;
}

先看第1环节，为什么9还原成浮点数，就成了0.000000？

9以整型的形式存储在内存中，得到如下二进制序列：

0000 0000 0000 0000 0000 0000 0000 10011//内存中的数据形式

首先，将9的二进制序列按照浮点数的形式拆分，得到第一位符号位S=0，后面8位的指数E=00000000，最后23位的有效数字M=0000000000000000001001。

由于指数E全为0，所以符合E为全0的情况。因此，浮点数V就写成：

V=(-1)^0 * 0.00000000000000000001001 * 2^(-126) = 1.001 * 2^(-146)

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000。

再看第2环节，浮点数9.0，为什么整数打印是1091567616？

首先，浮点数9.0等于二进制的1001.0，即换算成科学计数法是：1.001×2^3

所以: 9.0 = ( − 1 ) 0 ∗ ( 1.001 ) ∗ 2 3 9.0 = (-1) ^0* (1.001) * 2^3 9.0=(−1)0∗(1.001)∗23,

那么,第一位的符号位S=0,有效数字M等于001后面再加20个0,凑满23位,指数E等于3+127=130,
即10000010

所以,写成二进制形式,应该是S+E+M,即

 0 10000010 001 0000 0000 0000 00000 0000//内存中的数据形式

这个32位的二进制数,被当做整数来解析并用于打印的时候,就是整数在内存中的补码,原码正是1091567616。

所以在打印数据的时候一定要注意占位符的使用，有符号的整数就应该用%d、无符号的整数就应该用%u、浮点数就应该用%f。错误的使用占位符也会打印出错误的形式。原因就是不用的占位符是从不同的角度看待内存中的数据。

造成在内存中相同的数据，打印出来的结果却不同的原因归根结底还是从何种角度去看待这些在内存中的数据。

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

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

相关文章

HTB：Sauna[WriteUP]

HTB：Sauna[WriteUP]

目录 连接至HTB服务器并启动靶机 信息收集 使用rustscan对靶机TCP端口进行开放扫描 将靶机TCP开放端口号提取并保存 使用nmap对靶机TCP开放端口进行脚本、服务扫描 使用nmap对靶机TCP开放端口进行漏洞、系统扫描 使用nmap对靶机常用UDP端口进行开放扫描 使用nmap对靶机…
阅读更多...
wireshark工具简介

wireshark工具简介

目录 1 wireshark介绍 2 wireshark抓包流程 2.1 选择网卡 2.2 停止抓包 2.3 保存数据 3 wireshark过滤器设置 3.1 显示过滤器的设置 3.2 抓包过滤器 4 wireshark的封包列表与封包详情 4.1 封包列表 4.2 封包详情 参考文献 1 wireshark介绍 wireshark是非常流行的网络…
阅读更多...
2025.1.20——一、[RCTF2015]EasySQL1 二次注入|报错注入|代码审计

2025.1.20——一、[RCTF2015]EasySQL1 二次注入|报错注入|代码审计

题目来源&#xff1a;buuctf [RCTF2015]EasySQL1 目录 一、打开靶机&#xff0c;整理信息 二、解题思路 step 1&#xff1a;初步思路为二次注入&#xff0c;在页面进行操作 step 2&#xff1a;尝试二次注入 step 3&#xff1a;已知双引号类型的字符型注入&#xff0c;构造…
阅读更多...
kong 网关和spring cloud gateway网关性能测试对比

kong 网关和spring cloud gateway网关性能测试对比

该测试只是简单在同一台机器设备对spring cloud gateway网关和kong网关进行对比&#xff0c;受限于笔者所拥有的资源&#xff0c;此处仅做简单评测。 一、使用spring boot 的auth-service作为服务提供者 该服务提供了一个/health接口&#xff0c;接口返回"OK"&…
阅读更多...
winfrom项目，引用EPPlus.dll实现将DataTable 中的数据保存到Excel文件

winfrom项目，引用EPPlus.dll实现将DataTable 中的数据保存到Excel文件

最近研究不安装office也可以保存Excel文件&#xff0c;在网上查询资料找到这个方法。 第一步&#xff1a;下载EPPlus.dll文件&#xff08;自行去网上搜索下载&#xff09; 第二步&#xff1a;引用到需要用的项目中&#xff0c;如图所示&#xff1a; 第三步&#xff1a;写代码…
阅读更多...
框架层实现cpu高负载(cpuload)的检测方案

框架层实现cpu高负载(cpuload)的检测方案

摘要 这是2018年在小厂的老方案了&#xff0c;现在看方案已经过时了也不太合理&#xff0c;仅供参考&#xff0c;上层框架开启一个5分钟定时器&#xff0c;检测5分钟内总cpu负载和每个线程cpu负载情况&#xff0c;当检测到cpu负载大于绿盟性能或功耗定义的阈值时&#xff0c;结…
阅读更多...
Android BitmapShader简洁实现马赛克，Kotlin（一）

Android BitmapShader简洁实现马赛克，Kotlin（一）

Android BitmapShader简洁实现马赛克&#xff0c;Kotlin&#xff08;一&#xff09; 这一篇&#xff0c; Android使用PorterDuffXfermode模式PorterDuff.Mode.SRC_OUT橡皮擦实现马赛克效果&#xff0c;Kotlin&#xff08;3&#xff09;-CSDN博客 基于PorterDuffXfermode实现马…
阅读更多...
人工智能在数字化转型中的角色：从数据分析到智能决策

人工智能在数字化转型中的角色：从数据分析到智能决策

引言 在数字化转型浪潮中&#xff0c;人工智能&#xff08;AI&#xff09;正迅速崛起&#xff0c;成为推动企业创新和变革的关键力量。面对日益复杂的市场环境和激烈的行业竞争&#xff0c;企业亟需借助技术手段提高运营效率、优化决策过程&#xff0c;并增强市场竞争力。而AI…
阅读更多...
「全网最细 + 实战源码案例」设计模式——工厂方法模式

「全网最细 + 实战源码案例」设计模式——工厂方法模式

核心思想 简单工厂模式是一种创建者模式&#xff0c;它通过一个工厂类负责创建不同类型的对象&#xff0c;根据传入的参数决定实例化的具体类&#xff0c;也被称为“静态工厂方法”模式&#xff0c;因为工厂方法通常是静态的。 结构 1. 工厂类&#xff1a; 提供一个静态方法…
阅读更多...
我的图形布局 组织结构图布局

我的图形布局 组织结构图布局

组织结构图布局,有的人也叫它树状布局,在图形中是经常用到的布局算法.形成类似如下图的图形布局方式 首先创建一个类, public class TreeLayouter {private int m_space 40;/// <summary>/// 空间间隔/// </summary>public int Space{get { return m_space; }se…
阅读更多...
Golang：使用DuckDB查询Parquet文件数据

Golang：使用DuckDB查询Parquet文件数据

本文介绍DuckDB查询Parquet文件的典型应用场景&#xff0c;掌握DuckDB会让你的产品分析能力更强&#xff0c;相反系统运营成本相对较低。为了示例完整&#xff0c;我也提供了如何使用Python导出MongoDB数据。 Apache Parquet文件格式在存储和传输大型数据集方面变得非常流行。最…
阅读更多...
Rust Actix Web 项目实战教程 mysql redis swagger：构建用户管理系统

Rust Actix Web 项目实战教程 mysql redis swagger：构建用户管理系统

Rust Actix Web 项目实战教程&#xff1a;构建用户管理系统 项目概述 本教程将指导你使用 Rust 和 Actix Web 构建一个完整的用户管理系统&#xff0c;包括数据库交互、Redis 缓存和 Swagger UI 文档。 技术栈 Rust 编程语言Actix Web 框架SQLx (MySQL 数据库)Redis 缓存Uto…
阅读更多...
校园网上店铺的设计与实现(代码+数据库+LW)

校园网上店铺的设计与实现(代码+数据库+LW)

摘 要 如今社会上各行各业&#xff0c;都喜欢用自己行业的专属软件工作&#xff0c;互联网发展到这个时候&#xff0c;人们已经发现离不开了互联网。新技术的产生&#xff0c;往往能解决一些老技术的弊端问题。因为传统校园店铺商品销售信息管理难度大&#xff0c;容错率低&a…
阅读更多...
生成对抗网络（GAN）入门与编程实现

生成对抗网络（GAN）入门与编程实现

生成对抗网络&#xff08;Generative Adversarial Networks, 简称 GAN&#xff09;自 2014 年由 Ian Goodfellow 等人提出以来&#xff0c;迅速成为机器学习和深度学习领域的重要工具之一。GAN 以其在图像生成、风格转换、数据增强等领域的出色表现&#xff0c;吸引了广泛的研究…
阅读更多...
26、正则表达式

26、正则表达式

目录 一. 匹配字符 .&#xff1a;匹配除换行符外的任意单个字符。 二. 位置锚点 ^&#xff1a;匹配输入字符串的开始位置。 $&#xff1a;匹配输入字符串的结束位置。 \b&#xff1a;匹配单词边界。 \B&#xff1a;匹配非单词边界。 三. 重复限定符 *&#xff1a;匹配…
阅读更多...
电子应用设计方案101：智能家庭AI喝水杯系统设计

电子应用设计方案101：智能家庭AI喝水杯系统设计

智能家庭 AI 喝水杯系统设计 一、引言 智能家庭 AI 喝水杯系统旨在为用户提供个性化的饮水提醒和健康管理服务&#xff0c;帮助用户养成良好的饮水习惯。 二、系统概述 1. 系统目标 - 精确监测饮水量和饮水频率。 - 根据用户的身体状况和活动量&#xff0c;智能制定饮水计划。…
阅读更多...
数据表中的数据查询

数据表中的数据查询

文章目录 一、概述二、简单查询1.列出表中所有字段2.“*”符号表示所有字段3.查询指定字段数据4.DISTINCT查询 三、IN查询四、BETWEEN ADN查询1.符合范围的数据记录查询2.不符合范围的数据记录查询 五、LIKE模糊查询六、对查询结果排序七、简单分组查询1.统计数量2.统计计算平均…
阅读更多...
【HarmonyOS NAPI 深度探索12】创建你的第一个 HarmonyOS NAPI 模块

【HarmonyOS NAPI 深度探索12】创建你的第一个 HarmonyOS NAPI 模块

【HarmonyOS NAPI 深度探索12】创建你的第一个 HarmonyOS NAPI 模块 在本篇文章中&#xff0c;我们将一步步走过如何创建一个简单的 HarmonyOS NAPI 模块。通过这个模块&#xff0c;你将能够更好地理解 NAPI 的工作原理&#xff0c;并在你的应用中开始使用 C 与 JavaScript 的…
阅读更多...
步入响应式编程篇（二）之Reactor API

步入响应式编程篇（二）之Reactor API

步入响应式编程篇&#xff08;二&#xff09;之Reactor API 前言回顾响应式编程Reactor API的使用Stream引入依赖Reactor API的使用流源头的创建 reactor api的背压模式发布者与订阅者使用的线程查看弹珠图查看形成新流的日志 前言 对于响应式编程的基于概念&#xff0c;以及J…
阅读更多...
Unity Line Renderer Component入门

Unity Line Renderer Component入门

Overview Line Renderer 组件是 Unity 中用于绘制连续线段的工具。它通过在三维空间中的两个或两个以上的点的数组&#xff0c;并在每个点之间绘制一条直线。可以绘制从简单的直线到复杂的螺旋线等各种图形。 1. 连续性和独立线条 连续性&#xff1a;Line Renderer 绘制的线条…
阅读更多...
最新文章

Copyright @ 2022~2023