【C语言】基础篇四、操作符

最新推荐文章于 2024-08-14 07:21:13 发布
最新推荐文章于 2024-08-14 07:21:13 发布
阅读量61 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bit_sm/article/details/131446261
版权

1、操作符分类

  1. 算数操作符
  2. 移位操作符
  3. 位操作符
  4. 赋值操作符
  5. 单目操作符
  6. 关系操作符
  7. 逻辑操作符
  8. 条件操作符
  9. 逗号表达式
  10. 下标引用、函数调用和结构成员

算数操作符

+         -         *         /         %
加        减        乘        除        取模
  • /

除法：除数不能为0

除法分类：

  1. 整数除法
  2. 浮点数除法（除号两边必须至少有一个浮点数，才能进行浮点数除法）：
printf("%f\n", 3 / 2);//1
printf("%f\n", 3 / 2.0);//1.500000
  • %

取模：结果为余数（操作数必须都是整数）

printf("%d\n", 9 % 2);//1

移位操作符

操作数都是整数，移动的都是补码

tip： 不要移动负数位，因为这是标准未定义行为，如：a << -1

    <<                  >>
左移操作符            右移操作符

原码、反码、补码

在线计算1、在线计算2

整数的二进制表示有3种形式：原码、反码、补码，在内存中和实际计算过程，都是使用补码

非负整数的原码、反码、补码均相同；负整数的原码正常，反码、补码则需要计算

**符号位：**原码（、反码、补码）最高位

0——整数；1——负数

eg、5的原码（、反码、补码）为00000000 00000000 00000000 00000101（x86环境）

eg、-5的原码为10000000 00000000 00000000 00000101（x86环境）

转换规则：（负数）

eg、-5的转换规则：

原码→反码：符号位不变，其它位按位取反（0变1，1变0）

10000000 00000000 00000000 00000101`→`11111111 11111111 11111111 11111010

反码→补码：末位+1（即反码+1）

11111111 11111111 11111111 11111010`→`11111111 11111111 11111111 11111011

还原规则：（负数）

  1. 方法1：

补码-1得到反码；反码符号位不变，其它位按位取反

  1. 方法2：

符号位不变，其它位按位取反；末位+1

左移操作符

**移位规则：**左边丢弃、右边补0

//案例1：5
int a = 5;
printf("%d\n", a << 1);//10

解析：（均为补码，下同）

00000000 00000000 00000000 00000101`→0`00000000 00000000 00000000 0000101``0
//案例2:-5
int a = -5;
printf("%d\n", a << 1);//-10

解析：

11111111 11111111 11111111 11111011`→1`11111111 11111111 11111111 1111011``0

右移操作符

右移运算规则分两种：

  1. **逻辑右移：**右边丢弃，左边补0
  2. **算术右移：**右边丢弃，左边用原来的符号位填充

具体使用哪种取决于编译器（一般使用算数右移）

int a = -5;
printf("%d\n", a >> 1);//-3

解析：

11111111 11111111 11111111 11111011→1``1111111 11111111 11111111 111111011

位操作符

操作数都是整数，操作的都是补码

  &                 |                  ^
按位与             按位或             按位异或
  • **&：**对应位置，同1得1，否则为0
printf("%d", 3 & -5);//3

解析：

00000000 00000000 00000000 00000011
11111111 11111111 11111111 11111011
↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓
00000000 00000000 00000000 00000011
  • **|：**对应位置，同0得0，否则为1
printf("%d", 3 | -5);//-5

解析：

00000000 00000000 00000000 00000011
11111111 11111111 11111111 11111011
↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓
11111111 11111111 11111111 11111011
  • **^：**对应位置，相同为0，相异为1
printf("%d", 3 ^ -5);//-8

解析：

00000000 00000000 00000000 00000011
11111111 11111111 11111111 11111011
↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓ ↓↓↓↓↓↓↓↓
11111111 11111111 11111111 11111000
  • 异或公式：
  1. a ^ a = 0（相同为0）
  2. a ^ 0 = a（相异为1）
  3. a ^ b ^ b = a（双重异或等于不异或）
  4. b ^ a ^ b = a（加法交换律）

练习：

**1、**从1 2 3 4 1 2 3 4 5中找出只出现1次的数

思路：两两异或，遍历后结果没有为0的，即为只出现1次的数字

#include <stdio.h>

int main()
{
    int arr[10] = { 1, 2, 3, 4, 1, 2, 3, 4, 5 };
    int i = 0;//比较源
    int j = 0;//比较目标
    for (i = 0; i <= 8; i++)
    {
        int flag = 1;//默认是单独数
        for (j = 0; j <= 8; j++)
        {
            if ((0 == (arr[i] ^ arr[j])) && (i != j))//注意操作符优先级
            {
                flag = 0;//不是单独数
                break;
            }
        }
        if (1 == flag)
        {
            printf("%d ", arr[i]);
        }
    }
    return 0;
}

**2、**两变量交换，不能创建第三个临时变量（实际软件开发推荐tmp方法）

  1. 加减法

缺点：容易溢出

int a = 3;
int b = 5;

a = a + b;
b = a - b;
a = a - b;
  1. 异或法

优点：二进制位数固定，不会出现溢出

缺点：只能作用于整数，可读性不高，效率不高

int a = 3;
int b = 5;

a = a ^ b;
b = a ^ b;
a = a ^ b;

解析：

  1. a' = a ^ b
  2. b' = a' ^ b = a ^ b ^ b = a
  3. a" = a' ^ b' = a ^ b ^ a = b

**3、**求一个整数存储在内存中的二进制中1的个数

思路1：利用&和>>，将整数每一位按位与1，记录结果为1的次数

int a = 0;
scanf("%d", &a);
int i = 0;
int count = 0;
for (i = 0; i < 32; i++)
{
    if ((a >> i) & 1);
        count++;
}
printf("%d\n", count);

思路2：某二进制序列&(二进制序列-1)，结果为该二进制序列中少一个1，多一个0

举例：

110 & 101 == 100`，`101 & 100 == 100
int a = 0;
scanf("%d", &a);
int i = 0;
int count = 0;
while (a)
{
    count++;
    a = a & (a - 1);//每次执行后，补码少一个1
}
printf("%d\n", count);

赋值操作符

//连续赋值：可读性差
a = x = y+1;

复合赋值符

+=    -=    *=    /=    %=    >>=    <<=    &=    |=    ^=

单目操作符

!            逻辑反操作
-            负值
+            正值
&            取地址（取的是内存中的地址）
sizeof       操作数的类型长度（以字节为单位）
~            对一个数的二进制按位取反（所有位）
--           前置、后置--
++           前置、后置++
*            间接访问操作符（解引用操作符）
(类型)       强制类型转换
  • !
if (!num)//假变真，真变假，num为假，要做...
if (num == 0)//与上等价

//C语言中C99之前没有表示真假的类型
//C99中引用了布尔类型
#include <stdbool.h>//需要引头文件
int main()
{
    _Bool a = true;
    bool b = false;//_Bool或bool都可以
    return 0;
}
  • &
int a = 10;
int* pa = &a;//取出整型的地址，放到整型指针中

int arr[10] = { 0 };
&arr;//取出数组的地址，应该放到【数组指针】中去

struct S
{
    char name[20];
    int age;
}
int main()
{
    struct S s = { 0 };
    struct S* ps = &s;
    return 0;
}
  • sizeof
//计算类型创建的变量所占内存的大小，单位是字节
int a = 10;
printf("%d\n", sizeof a);//4
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof int);//错误
//sizeof是操作符，而不是函数，所以可以省略()写成sizeof a，但是不能省略类型的括号sizeof int（语法错误）

int arr[10] = { 0 };
printf("%d\n", sizeof(arr));//40
printf("%d\n", sizeof(int [10]));//40
printf("%d\n", sizeof(int [5]));//20

int a = 10;
short s = 0;
printf("%d\n", sizeof(s = a + 2));//2，sizeof()中的表达式不参与计算，4字节赋给2字节发生截断，大小还是2字节；但as互换，结果则为4
printf("%d\n", s);//0
#include <stdio.h>

void test1(int arr[])
{
        printf("%d\n", sizeof(arr));//4/8
}

void test2(char ch[])
{
        printf("%d\n", sizeof(ch));//4/8
}

int main()
{
        int arr[10] = { 0 };
        char ch[10] = { 0 };
        printf("%d\n", sizeof(arr));//40
        printf("%d\n", sizeof(ch));//10
        test1(arr);
        test2(ch);
        return 0;
}
  • ~：全部取反
int a = 0;
printf("%d\n", ~a);//-1

a = 11;
//00000000 00000000 00000000 00001011为a的补码，想让它右数第三位0变1
//00000000 00000000 00000000 00000100需要按位或4
//00000000 00000000 00000000 00001111得到15的补码
a |= (1 << 2);
printf("%d\n", a);//15
//00000000 00000000 00000000 00001111为a的补码，想让它右数第三位1变0
//11111111 11111111 11111111 11111011需要按位与此序列
//00000000 00000000 00000000 00001011得到11的补码
a &= (~(1 << 2));
printf("%d\n", a);//11

//为什么while(~scanf("%d", &n))与while(scanf("%d", &n) != EOF)作用相当，可以终止循环
//scanf()读取失败的时候，返回EOF，本质是-1
//-1的补码是11111111 11111111 11111111 11111111
//~-1的补码是00000000 00000000 00000000 00000000
//所以...
  • ++
  • –
int a = 3;
int b = ++a;//前置++，先+1，后使用，即先a = a + 1，再b = a
b = a--;//后置--，先使用，后-1，即先b = a，再a = a - 1
  • ()
int a = (int)3.14;
printf("%d\n", a);
//强制类型转换，不推荐使用

关系操作符

>           >=           <           <=           !=           ==

两个字符串不能用<、==、>判断相等，而应该使用strcmp函数

"abcdef" == "abbq"//语法没问题，但比较的是两字符串首字符的地址，所以永远不相等

逻辑操作符

    &&                        ||
逻辑与（并且）             逻辑或（或者）

a && b：全真为1，否则为0；左边为假，右边不进行计算

a || b：全假为0，否则为1；左边为真，右边不进行计算

注意区分：逻辑与/或（&& / ||）和按位与/或（& / |）

练习：

int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;//&&左边为0，右边就不进行计算
printf("%d %d %d %d\n", a, b, c, d);//1 2 3 4

i = 0, a = 1, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("%d %d %d %d\n", a, b, c, d);//2 3 3 5

i = 0, a = 1, b = 2, c = 3, d = 4;
i = a++ || ++b || d++;//||左边为真时，右边就不进行计算
printf("%d %d %d %d\n", a, b, c, d);//2 2 3 4

i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ || ++b || d++;
printf("%d %d %d %d\n", a, b, c, d);//1 3 3 4

条件操作符

exp1 ? exp2 : exp3//exp1若为真，执行exp2，并作为结果；exp1若为假，执行exp3，并作为结果

举例：求较大值

max = (a > b ? a : b);

逗号表达式

从左向右依次执行，最后一个表达式的结果是整个表达式结果

exp1, exp2, exp3, …expN
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);//c为13
a = get_val();
count_val(a);
while (a > 0)
{        
        //业务处理
        a = get_val();
        count_val(a);
}

//可以改写成
while (a = get_val(), count_val(a), a > 0)
{
        //业务处理
}

下标引用、函数调用和结构成员

  1. []下标引用操作符

操作数：数组名 + 索引值

arr[4] == 4[arr] == *(arr + 4)

  1. ()函数调用操作符

至少接受一个操作数：第一个操作数是函数名，其余的操作数就是传递给函数的参数

  1. 结构成员操作符
.        结构体变量.成员名
->       结构体指针->成员名
#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <string.h>

struct Stu
{
    char name[20];
    int age;
    float score;
};

void print1(struct Stu ss)
{
    printf("%s %d %f\n", ss.name, ss.age, ss.score);
}

void print2(struct Stu* ps)
{
    printf("%s %d %f\n", (*ps).name, (*ps).age, (*ps).score);
    printf("%s %d %f\n", ps->name, ps->age, ps->score);
}

int main()
{
    struct Stu s = { "张三", 20, 90.5f };
    //打印
    print1(s);
    print2(&s);
    //修改
    s.name = "张三丰";//错误示范1，因为name是数组，表示首元素地址
    *(s.name) = "张三丰";//错误示范2，解引用只能访问到一个字符，而张三丰是一个字符串，不能放进一个字符
    strcpy(s.name, "张三丰");//正确示范1
    scanf("%s", s.name);//正确示范2
    return 0;
}
#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <string.h>

struct Book
{
    char name[30];
    float price;
};

void print1(struct Book b1)
{
    printf("%s %.1f\n", b1.name, b1.price);
}

void print2(struct Book* pb1)
{
    printf("%s %.1f\n", (*pb1).name, (*pb1).price);
    printf("%s %.1f\n", pb1->name, pb1->price);
}

int main()
{
    struct Book b1 = { "C语言从入门到精通", 66.5f };
    //打印
    print1(b1);
    print2(&b1);
    //修改
    b1.name = "C语言从入门到入坟";//错误示范，因为name是数组，表示首元素地址
    *(b1.name) = "C语言从入门到入坟";//错误示范，解引用只能访问到一个字符，而张三丰是一个字符串，不能放进一个字符
    strcpy(b1.name, "C语言从入门到入坟");//正确示范
    b1.price = 50.5f;
    //输入
    scanf("%s", b1.name);
    scanf("%f", &b1.price);
    return 0;
}

表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型（类型转换）

隐式类型转换

C语言的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升（只针对大小小于int的char、short类型）

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

char c1 = 3;
char c2 = 127;
char c3 = c1 + c2;
printf("%d\n", c3);
  1. 截断

3的补码00000000 00000000 00000000 00000011，要放到char类型的c1里面，但是放不下，会发生截断，将后8个比特位存到c1中，即00000011

127的补码00000000 00000000 00000000 01111111，同理c2存入01111111

  1. 整型提升（针对大小小于int的char、short）

char、short类型进行表达式计算时，会发生整型提升

整型提升是按照变量的数据类型的符号位来提升的，即补符号位（无符号整型提升，高位补0）

因为char默认是signed char，0为符号位，所以整型提升时，高位补符号位，得到

00000000 00000000 00000000 00000011，同理c2整型提升后为00000000 00000000 00000000 01111111

  1. 计算

00000000 00000000 00000000 00000011 + 00000000 00000000 00000000 01111111

= 00000000 00000000 00000000 10000010

得到的结果放入char类型的c3，发生截断，存入10000010

  1. 打印

打印整型，但c3是char类型，发生整型提升得到11111111 11111111 11111111 10000010（补码）

还原为原码为10000000 00000000 00000000 01111110，故打印-126

int main()
{
    char a = 0xb6;
    short b = 0xb600;
    int c = 0xb6000000;
    
    if (a == 0xb6)//10110110，整型提升后变成负数，所以不会打印
        printf("a");
    if (b == 0xb600)//10 11011000，截断、整型提升后变成负数，所以不会打印
        printf("b");
    if (c == 0xb6000000)//本就是int类型，不发生截断和整型提升，所以相等
        printf("c");//c
    return 0;
}

tip：1个十六进制位能转化为4个二进制位

int main()
{
    char c = 1;
    printf("%u\n", sizeof(c));//1，不发生整型提升
    printf("%u\n", sizeof(+c));//4，发生整型提升
    printf("%u\n", sizeof(-c));//4，发生整型提升
    return 0;
}//解析：c参与表达式运算时，发生整形提升
//%d 十进制形式打印有符号整数
//%u 十进制形式打印无符号整数
  • 类型与符号

char（没有规定char到底是有符号还是无符号的char，但在VS2022及大部分编译器下，char == signed char）

signed char

unsigned char

short == signed short

unsigned short

int == signed int

unsigned int

算术转换

大于等于整型大小时使用

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换

↑ long double

↑ double

↑ float

↑ unsigned longint

↑ long int

↑ unsigned int

↑ int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算

警告：

但是算术转换要合理，要不然会有一些潜在的问题

float f = 3.14;
int num = f;//隐式转换，会有精度丢失

操作符的属性

复杂表达式的求值有三个影响的因素：

  1. 操作符的优先级
  2. 操作符的结合性
  3. 是否控制求值顺序
  • 操作符的优先级

相邻操作符才讨论优先级

int a = 10;
int b = 20;
int c = a + b * 5;//*比+优先级高，所以先算乘法
  • 操作符的结合性

相邻操作符的优先级相同情况下，结合性起作用

N/A - 无结合性

L-R - 从左向右结合

R-L - 从右向左结合

int a = 10;
int b = 20;
int c = a + b + 5;

但是经过上述三点限制，依然会出现有多种路径进行计算的一些问题表达式：

//表达式1
a*b + c*d + e*f;

在计算的时候，由于*比+的优先级高，只能保证，的计算是比+早，但是优先级并不能决定第三个比第一个+早执行

//表达式2
c + --c;

不知道第一个c什么时候准备好，加入c = 2，不知道应该计算1+1还是2+1

//代码3 - 非法表达式
int main()
{
    int i = 10;
    i = i-- - --i * (i = -3) * i++ + ++i;
    printf("i = %d\n", i);
    return 0;
}

经测试，各个不同编译器下得出的结果均不相同，所以为非法表达式

//代码4
int fun()
{
    static int count = 1;
    return ++count;
}

int main()
{
    int answer;
    answer = fun() - fun() * fun();
    printf("%d\n", answer);
    return 0;
}

static出作用域不销毁，fun第一次返回2，第二次返回3，第三次返回4，虽然计算顺序确定，但是不知道第几个函数先被调用

//代码5
#include <stdio.h>
int main()
{
    int a = 1;
    int b = (++a) + (++a) + (++a);
    printf("%d\n", b);
    printf("%d\n", a);
    return 0;
}
//linux:10 4
//VS2022:12 4

不同平台的汇编代码有差异，可通过反汇编进行研究

总结：写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言知识点总结（基础篇）
05-23
### C语言知识点总结（基础篇） #### 1. C 语言概述 - **1.1 什么是 C 语言** C 语言是一种通用的、面向过程的编程语言，由Dennis Ritchie在1972年左右在贝尔实验室发明。它的出现主要是为了编写UNIX操作系统。C...
C语言基础九九乘法表代码
11-06
C语言中，使用`*`操作符进行乘法运算。 ```c printf("%d*%d=%d\t", i, j, i*j); ``` 5. **换行处理**：为了保持乘法表的整洁，每打印完一行的乘积后，我们需要在输出中插入一个换行符`\n`。 ```c // 在外层循环...
c语言基础篇：操作符
摸鱼胖嘟嘟的博客
07-14 646
c语言基础篇：操作符
编程小白学习C语言基础篇——操作符①
xupy019的博客
05-05 1477
操作符的分类：算术操作符：移位操作符:<< >> 移动的是二进制位位操作符:& | ^ 二进制位进行计算赋值操作符:+=-=*=/=%=<<=>>=&=|=^=单目操作符：！++--sizeof关系操作符: >>=<===!逻辑操作符：&&||条件操作符：?逗号表达式： ,下标引⽤：[ ]函数调⽤：( )
C语言基础--操作符详解
人生得意须尽欢
12-30 1483
C语言操作符详解，不要错过
【C语言基础】：操作符详解(二)
书山有路勤为径，学海无涯苦作舟。
02-26 3198
上期回顾：【C语言基础】：操作符详解(一)【练习一】：不能创建临时变量（第三个变量）， 实现两个整数的交换。方法一：我们可以运用加减法来实现这个功能。 分析：下面是代码实现： 很明显，这种方法也存在着明显的不足，那就是当a和b的值比较大时，a和b可能会超出int的范围，会出现溢出的现象，导致无法进行值的互换。方法二：按位异或实现 上次我们学习了位操作符，其中按位异或就是对应二进制位相同为0，相异为1。根据这个特性，我们也能实现这个功能。分析：下面说代码实现： 这种方法也存在着局限性，首先要知道按位操作符
C语言——操作符（详解）
sinzz的博客
11-16 2475
C语言中所有操作符详解
C语言最全操作符详解，一文精通所有操作符！
m0_57180439的博客
08-19 5208
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、除号“/”二、"%"除法取余数三、左移操作符“<<”和右移操作符“>>”1.左移操作符2.右移操作符四、按位与“&”五、按位或“|”六、按位异或“^”七、赋值操作符“=”和复合赋值操作符1.赋值操作符2.复合赋值操作符八、逻辑非“！”九、&取地址操作符和*解引用操作符十、sizeof操作符十一、按位取反操作符“~”十二、强制类型转换操作符 （类型）十三、双目操作符：逻辑与&&a
C语言基础知识:操作符详解（附操作符优先级及结合性一览表）
旋律 | 话语 | 色彩 | 情景
12-21 2553
C语言基础知识:操作符详解（附操作符优先级及结合性一览表）
C语言基础：操作符详解，看这一个就够了！（内含详细图解）
linsc_05的博客
08-04 3596
C语言中的操作符主要可以分为10个类型，这篇文章将带你详细了解各操作符的使用方法，希望能对你有帮助~
C语言基础篇及进阶
Tian_baby的博客
02-22 3202
B站鹏哥C语言学习笔记。
C语言基础 - 位操作用法总结
yunfan
02-18 2262
本文主要讲解了C语言的位操作的使用方法。
C语言声明学习之初级篇
01-19
　C语言为我们定义了四种基本数据类型：整型，浮点型，指针以及聚合类型（数组和结构体等），在此基础上，我们就可以声明变量。我们平时经常说定义一个某种类型的变量，其实这样说不确切，应该说是声明变量。 　...
C语言专题精讲篇--笔记汇总.pdf
03-26
2. 位操作：位操作符（如&、|、^、、>>）允许程序员以位为单位直接对内存中的数据进行操作，这对于处理二进制数据、优化性能以及操作硬件寄存器等场景非常重要。例如，在寄存器操作时，位与、位或、位异或等操作可...
c语言文本文件读写操作示例代码
03-19
本篇文章将基于提供的示例代码，深入讲解如何使用C语言的标准库来实现文本文件的基本读写操作。具体包括`fopen`, `fgets`, `fprintf`以及`fclose`等函数的使用方法。 #### 二、核心知识点 ##### 1. 文件打开与关闭...
LeetCode //C - 312. Burst Balloons
Made in Code
08-14 345
【代码】LeetCode //C - 312. Burst Balloons。
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
深度探索：神经网络在图像识别中的革命性应用
08-14
神经网络是一种受人脑结构启发的数学模型，它由大量的节点（或称为“神经元”）相互连接构成。这些节点通常组织成层，包括输入层、隐藏层和输出层。每个神经元可以接收来自前一层的输入，通过某种激活函数处理这些输入，然后将结果传递给下一层的神经元。 神经网络能够通过学习大量的数据来识别模式和特征，这使得它们在图像识别、语音识别、自然语言处理等领域有着广泛的应用。它们也可以用于预测、分类和回归等任务。 训练神经网络通常涉及到一个称为“反向传播”的过程，通过这个过程，网络可以调整其内部参数（权重和偏置），以便更好地完成特定的任务。这个过程通常需要大量的计算资源，并且伴随着梯度下降或其他优化算法来最小化损失函数，从而提高模型的性能。 随着深度学习技术的发展，神经网络变得更加复杂和强大，出现了各种类型的网络结构，比如卷积神经网络（CNNs）用于图像处理，循环神经网络（RNNs）用于序列数据，以及长短期记忆网络（LSTMs）等。
基础会计教学课件第十一章财务会计报告.pptx
08-14
基础会计教学课件第十一章财务会计报告.pptx
Linux操作系统C语言编程基础教程
“Linux操作系统下C语言编程入门，涵盖了基础知识、进程介绍、文件操作、时间概念、信号处理、消息管理、线程操作、网络编程以及Linux下的C开发工具。” 在Linux操作系统下，C语言编程是软件开发中的基础技能，它...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值