C语言学习 5.操作符

已于 2023-04-01 23:39:49 修改
阅读量190 收藏
点赞数
文章标签： c语言 学习 算法
于 2023-03-10 22:34:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52207839/article/details/129454222
版权
本文详细介绍了C语言中的各种操作符，包括算术操作符、移位操作符、位操作符、赋值操作符等，并提供了相关示例，如位操作符在交换变量、计数、判断2的幂等方面的应用，以及右移操作符的算术和逻辑移位区别。
摘要由CSDN通过智能技术生成

文章目录

操作符

1. 操作符的分类

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2. 算术操作符

+ - * / %
  1. 除%操作符外，其他几个操作符可用于整数和浮点数。
  2. 对于/操作符，如果两个操作数都是整数，执行整数除法，而只要有浮点数执行的就是浮点数除法。
  3. %操作符的两个操作数必须为整数，返回的是整除之后的余数。

3. 移位操作符

<< 左移操作符
>> 右移操作符
//位移操作符的操作数只能是整数，且操作的是内存中的补码。

3.1 左移操作符

位移规则：

左边抛弃，右边补零

3.2 右移运算符

移位规则：

  1. 逻辑移位

左边用0填充，右边丢弃

  1. 算术移位

左边用原该值的符号位填充，右边丢弃（编译器一般是算术移位）

int main()
{
	int a = -1;
	int b = a >> 1;
	printf("b = %d\n", b);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xir9F65I-1678456319812)(F:/typora%E5%9B%BE%E7%89%87/image-20230310215123090.png)]

可发现结果为算术右移

a=-1          1111111111111111111111111111//补码
右移>>1        1111111111111111111111111111
输出原码        1000000000000000000000000001//结果为-1

注意：

对于移位运算符不要移动负数位，这个是标准未定义的，例如：

int num = 10;
num>>-1;//error

4. 位操作符

位操作符有：

&   //按位与(都是1结果为1)
|   //按位或(一个为1结果为1)
^   //按位异或(相同为0，相异为1)
//都是按二进制，且操作数必须为整数

例：

#include<stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	a & b;//0011 & 0101 = 0001      
	a | b;//0011 | 0101 = 0111            
	a ^ b;//0011 ^ 0101 = 0110
	return 0;
}

注：

a ^ a = 0;
a ^ 0 = a;

4.1 不能创建临时变量(第三个变量)，实现两个数的交换

#include<stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("a = %d,b = %d\n",a, b);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bU5TXoLY-1678456319813)(img/image-20220809163923837.png)]

4.2 求一个整数储存在内存中的二进制中1的个数

#include<stdio.h>
//方法1
int main()
{
	int num = 10;
	int count = 0;
	while (num)
	{
		if (num % 2 == 1)
		{
			count++;
		}
		num /= 2;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}//写成函数用unsigned int接收可以计算负数中一的个数

//方法2
#include<stdio.h>

int main()
{
	int num = 10;
	int count = 0;
	int i = 0;
	for (i = 0;i < 32;i++)
	{
		if (num & (1<<i))
			count++;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JOETt7uE-1678456653294)(F:/typora%E5%9B%BE%E7%89%87/image-20230310215514299.png)]

//方法3
#include<stdio.h>
int main()
{
	int num = -1;//以补码形式计算
	int count = 0;
	int i = 0;
	while (num)
	{
		count++;
		num = num & (num - 1);
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QDYwEbsc-1678456319813)(img/image-20220809171614640.png)]

4.3 写一个代码判断一个数是不是2的n次方

//2的n次方的数字其中只有一个1
if(k&(k-1)==0)即为2的n次方数

4.4 求两个int(32位)整数m和n的二进制表达式中有多少个位（bit)不同

//方法1
#include<stdio.h>
int main()
{
	int m = 0;
	int n = 0;
	scanf("%d%d", &m, &n);
	int i = 0;
	int count = 0;
	for (i = 0;i < 32;i++)
	{
		if ((m & (1 << i) )!=( n & (1 << i)))
		{
			count++;
		}
	}
	printf("%d", count);
	return 0;
}

//方法2
#include<stdio.h>
int main()
{
	int m = 0;
	int n = 0;
	scanf("%d%d", &m, &n);
	int ret = m ^ n;//异或
	int count = 0;
	while (ret)
	{
		count++;
		ret = ret & (ret - 1);
	}
	printf("%d\n", count);
	return 0;
}

在这里插入图片描述

4.5 获取一个整数二进制序列中所有偶数位和奇数位，分别打印出二进制序列

#include<stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	int i = 0;
	//获取奇数位
	for (i = 30;i >=0;i -= 2)//最后一位需移动0位到末尾
	{
		printf("%d ", (n >> i) & 1);
	}
	printf("\n");
	//获取偶数位
	for (i = 31;i>=1;i -= 2)//最后一位需移动1位到末尾
	{
		printf("%d ", (n >> i) & 1);
	}
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6xhVvG5k-1678456319814)(img/image-20220814173821624.png)]

4.6 替换二进制中的某一位

//如将a = 13，00001101中第5个0替换为1
#include<stdio.h>
int main()
{
	int a = 13;
	a = a | (1 << 4);
	printf("a = %d\n", a);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g6bE2TcG-1678456319814)(img/image-20220809172344868.png)]

5.赋值操作符

复合赋值符

+=  -=  *=  /=  >>=  <<=  &=  |=  ^=
//连续赋值是把右边赋给左边，如b=a=a+5;但还是建议分开写便于调试

6.单目操作符

6.1 单目操作符介绍

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换

6.2 sizeof和数组

#include <stdio.h>
void test1(int arr[])
{
	printf("%d\n", sizeof(arr));//(1)
}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));//(2)
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//int类型为4个字节，所以4*10=40
	printf("%d\n", sizeof(ch));//char类型为1个字节，所以1*10=10
	test1(arr);
	test2(ch);//(1)和(2)传递的都是数组首地址，地址都是4个字节
	return 0;
}
//%zu专门用来接收sizeof的放回值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQqyUx0O-1678456319814)(img/image-20220809173425627.png)]

#include <stdio.h>
int main()
{
	short s = 5;
	int a = 10;
	printf("%d\n", sizeof(s = a + 2));//赋值运算不会改变类型，编译阶段已经完成了sizeof的计算，赋值是在程序运行阶段
	printf("%d\n", s);//sizeof括号内的表达式不参与运算
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l42hiwWv-1678456319814)(img/image-20220809174019304.png)]

6.3 ~操作符

//(1)如将a = 13，00001101中第5个0替换为1,(2)再将1替换回0
#include<stdio.h>
int main()
{
	int a = 13;
	a = a |(1 << 4);//(1)
	a = a & ~(1 << 4);//(2)
	printf("a = %d\n", a);
	return 0;
}
//改某位数为1就对应位&1，改为0就对应位|0

在这里插入图片描述

6.4 ++和–运算符

#include<stdio.h>
int main()
{
	int a = 10;
	int b = a++;//后置++，先使用，再++
	printf("a=%d b=%d\n",a, b);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hHnE2WmL-1678456319815)(img/image-20220809175544120.png)]

#include<stdio.h>
int main()
{
	int a = 10;
	int b = ++a;//前置++，先++，在使用
	printf("a=%d b=%d\n",a, b);
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sfUH9BX1-1678456319815)(img/image-20220809175639429.png)]

#include<stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", a--);
	printf("%d\n", a);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2a8KFJw4-1678456319815)(img/image-20220809175902850.png)]

7. 关系操作符

>  >=  <  <=  !=  ==

8. 逻辑操作符

&&  逻辑与  ||  逻辑或

区分逻辑与和按位与，逻辑或和按位或

1&2--->0
1&&2--->1
    
1|2--->3
1||2--->1

例：

#include<stdio.h>
int main()
{
    int i = 0, a = 0, b = 2, c = 3, d = 4;
    i = a++ && ++b && d++;//a初始为0,a&&后面结果必为0，所以后面不运算,i=0
    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FJyMSrM8-1678456319815)(img/image-20220809180832820.png)]

#include<stdio.h>
int main()
{
    int i = 0, a = 1, b = 2, c = 3, d = 4;
    i = a++ || ++b || d++;//a初始为1，a||后面结果必为1，所以后面不运算,i=1
    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mzayC0CK-1678456319816)(img/image-20220809181147186.png)]

9. 条件操作符

exp1 ? exp2 : exp3
//例：
    if(a>5)
        b=3;
    else
        b=5;
//转化为条件操作符
    b = ((a > 5) ? 3 : 5 )

10. 逗号表达式

exp1,exp2,exp3,...,expN
//例1：
    int a = 1;
    int b = 2;
    int c = ( a > b , a = b + 10 , a ,b = a + 1)//结果为最后一个表达式的结果，b-13，第一个表达式的值为0
        
//例2：
a = get();
	count(a);
	while (a > 0)
	{
		//业务处理
		a = get();
		count(a);
	}
 //代码冗余，改成三木操作符
	while (a = get(), count(a), a > )
	{}

逗号表达式从左向右进行，整个表达式的结果是最后一个表达式的结果

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

  1. [ ]下标引用操作符

操作数：一个数组名+一个索引值

  1. ( )函数调用操作符

接受一个或多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数

  1. 访问一个结构的成员

. 结构体变量名.成员名

-> 结构体指针->成员名

struct Book
{
    char name[20];
    char id[20];
    int price;
};
//变量名访问
int main()
{
    struct Book b = { "C语言","2022",18};
    printf("书名：%s\n", b.name);
    printf("书号：%s\n", b.id);
    printf("价格：%d\n", b.price);
    return 0;
}

//指针访问
int main()
{
    struct Book b = { "C语言","2022",18};
    struct Book* pb = &b;
    printf("书名：%s\n", (*pb).name);
    printf("书号：%s\n", (*pb).id);
    printf("价格：%d\n", (*pb).price);
    return 0;
}

    struct Book b = { "C语言","2022",18};
    struct Book* pb = &b;
    printf("书名：%s\n", pb->name);
    printf("书号：%s\n", pb->id);
    printf("价格：%d\n", pb->price);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-srrx6CdO-1678456319816)(img/image-20220809195336984.png)]

12. 表达式求值

表达式求值的顺序一部分由操作符的优先级和结合性决定，同样，有些表达式的操作数在求值过程中可能需要转化为其他类型。

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。 为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

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

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

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

如何进行整型提升

整型提升是按照变量的数据类型的符号位来提升的。

//负数的整型提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111

//正数的整型提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整型提升，高位补0

例1：

#include<stdio.h>
int main()
{
    char a = 3;//00000011
    char b = 127;//01111111
    char c = a + b;//先提升，再截断
    printf("%d\n", c);//%d打印，需要再次整型提升
    return 0;
}
//先按符号位整型提升得c=11111111111111111111111110000010
//截断后c=10000010，打印成%d的形式又发生整型提升，并且返回原码
//先减1， 11111111111111111111111110000001
//再取反，10000000000000000000000001111110
//输出结果即为-126

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wltMmLXX-1678456319816)(img/image-20220809205051832.png)]

例2：

#include<stdio.h>
int main()
{
	char a = 0xb6;//10110110
	short b = 0xb600;
	int c = 0xb6000000;
	if (a == 0xb6)
		printf("a");
	if (b == 0xb600)
		printf("b");
	if (c == 0xb6000000)
		printf("c");
	return 0;
}

实例2中的a,b（都达不到整型大小）要进行整型提升,但是c不需要整形提升 a,b整形提升之后,变成了负数,所以表达式 a=0xb6 ,b=0xb600的结果是假,但是c不发生整形提升,则表 达式 c==0xb6000000 的结果是真. 所程序输出的结果是: c。

例3：

int main()
{
  char c = 1;
  printf("%u\n", sizeof(c));
  printf("%u\n", sizeof(+c));
  printf("%u\n", sizeof(-c));
  return 0;
}
//%u是无符号10进制数

实例3中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字 节. 表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节
在这里插入图片描述

例4：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
    unsigned char a = 200;
    unsigned char b = 100;
    unsigned char c = 0;
    //char类型只能存8个bit位
    //11001000 -a
    //01100100 -b

    c = a + b;
    //发生整型运算需要提升
    //00000000000000000000000100101100  十进制为300
    //00101100 -c  十进制为44

    printf("%d %d", a + b, c);//a+b运算后直接输出，不需要截断，
                              //而c要先截断保留8bit位再提升

    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U8hLF38T-1678456319816)(F:/typora%E5%9B%BE%E7%89%87/image-20230308183721055.png)]

12.2 算术转换

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

long double
double
float
unsigned long int
long int
unsigned int
int

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

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

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

12.3 操作符的属性

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

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

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。 操作符优先级。我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

#include<stdio.h>

int main()
{
	int a, b, c;
	a = 5;
	c = ++a;//c=6,a=6
	b = ++c, c++, ++a, a++;//c=8,b=7,a=8
	b += a++ + c;//+=优先级低，实际上为 b += (a++ + c)先使用a再++ , a=9,c=8,b=23
	printf("a = %d b = %d c = %d\n", a, b, c);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z7QwfMrv-1678456319817)(img/image-20220814160031946.png)]

13. 练习

#include <stdio.h>
int i;//i是全局变量，不是初始化，默认为0

int main()
{
    i--;
    if (i > sizeof(i))
        //sizeof操作符算出的结果的类型是unsigned int,比较时会将i转化成无符号型
    {
        printf(">\n");
    }
    else
    {
        printf("<\n");
    }
    return 0;
}
//故输出结果为 >
  1. 求Sn=a+aa+aaa+aaaa+aaaaa的前n项之和，其中a为一个数字。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
    int a = 0;
    int n = 0;
    scanf("%d%d", &a, &n);
    int i = 0;
    int sum = 0;
    int ret = 0;
    for (i = 0;i < n;i++)
    {
        ret = ret * 10 + a;
        sum += ret;
    }
    printf("%d\n", sum);
    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rbFcR8bN-1678456319817)(F:/typora%E5%9B%BE%E7%89%87/image-20230308163502127.png)]

  1. 打印水仙花数，求出0~100000之间的所有水仙花数并输出。

水仙花数是指一个n位数，其各个位的n次方之和恰好等于该数本身，如153=13+53+33

#include <stdio.h>
#include<math.h>
int main()
{
    int i = 0;
    for (i = 0;i <= 100000;i++)
    {
        //计算i的位数
        int n = 1;
        int tmp = i;
        while (tmp / 10)
        {
            n++;
            tmp = tmp / 10;
        }
        //计算每一位的n次方之和
        tmp = i;
        int sum = 0;
        while (tmp) 
        {
            sum += pow(tmp % 10, n);
            tmp /= 10;
        }
        if (sum == i)
        {
            printf("%d ", i);
        }
    }
    printf("\n");
    return 0;
}

在这里插入图片描述

4.变种水仙花数：把任意的数字，从中间拆分成两个数字，比如1461 可以拆分成（1和461）,（14和61）,（146和1),如果所有拆分后的乘积之和等于自身，则是一个Lily Number。

例如：

655 = 6 * 55 + 65 * 5

1461 = 1461 + 1461 + 146*1

求出 5位数中的所有 Lily Number。

#include <stdio.h>
#include<math.h>
int main()
{
    int i = 0;
    for (i = 10000; i <= 99999; i++)
    {
        int j = 0;
        int sum = 0;
        for (j = 1; j <= 4; j++)
        {
            int k = pow(10, j);
            sum += (i / k) *( i % k);
        }
        if (i == sum)
        {
            printf("%d ",i);
        }
    }
    return 0;
}

在这里插入图片描述

clllk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C语言学习】————操作符、关键字
m0_52751535的博客
04-09 1170
4_6学习浅谈操作符关键字指针 操作符 单目操作符 ++ - - ~ & * ++与- -操作符分为前置与后置关系，看如下代码： int a = 10; int b = ++a; printf("%d\n %d", a, b);//看一下a与b的值为多少。 这输入一个前置++问题，代表先进行++操作符的运算，而后进行=操作符的运算。故b=11，a=11. 下面看一个后置++代码： int a = 10; int b = a++; pri
C语言学习总结5——操作符
weixin_45760797的博客
06-09 1306
介绍了C语言中常见的操作符，如：算术、移位操作符等
【C语言学习】6.初识操作符
Unbantucniak的博客
07-15 1148
- * / % 加、减、乘、除、取模。
C语言操作符汇总
2301_81200576的博客
05-02 777
本文将详细分享C语言常见的11种操作符>& | ^+=-=*=/=%==&=|=、^=！++、--sizeof类型>=
C语言基础：操作符详解，看这一个就够了！（内含详细图解）
linsc_05的博客
08-04 4583
C语言中的操作符主要可以分为10个类型，这篇文章将带你详细了解各操作符的使用方法，希望能对你有帮助~
C语言学习（三）之操作符
qq_46292926的博客
10-31 1392
C语言学习记录（三）之操作符
C语言：位操作符详解
盒马的博客
10-01 1475
讲解C语言的位操作符。
C语言--13.操作符详解
平生的小铺子
06-06 1628
在我们c语言中，有各式各样的操作符，这些操作符完成了我们对于数据的各种处理，所以它们在我们c语言中是必不可少的，加下来就让我们一起来认识一下着各式各样的操作符吧 在我们这一章中主要会介绍下列操作符与问题 算术操作符 移位操作符 位操作符 赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号表达式 下标引用、函数调用和结构成员 表达式求值 算术操作符 首先我们来介绍我们最熟悉的算术操作符，这些曹、从小到大耳濡目染的操作符 + - *...
C语言——操作符（详解）
sinzz的博客
11-16 2514
C语言中所有操作符详解
C语言操作符详解
k666499436的博客
05-25 6265
深度理解取余/取模运算，以及逻辑运算符， 位操作符，移位操作符，以及深入理解a++
C语言学习项目.zip
01-05
"C语言学习项目.zip"可能包含了一系列的教程、代码示例、练习题和解决方案，旨在帮助用户全面掌握C语言的基础和高级概念。 C语言的核心知识点包括： 1. **基本语法**：C语言的基础是它的语法结构，包括变量声明、...
C语言学习笔记.docx
04-21
5. **高级和低级语言特性结合**：C语言允许直接访问内存地址，进行位操作，同时具有高级语言的抽象能力。 6. **高效的执行**：C语言编译后的目标代码执行效率高，接近汇编语言。 7. **良好的可移植性**：C语言编写的...
C语言学习笔记.pdf
09-30
总的来说，C语言的学习需要掌握基础的数据类型、运算规则以及输入输出操作。深入理解这些概念，将有助于编写出高效、可靠的C语言程序。通过实践和不断练习，能够更好地掌握这门语言的精髓，从而在软件开发领域中...
C语言提高讲义.doc
07-22
- `*`操作符是解引用操作，用于访问指针所指向的内存。 - 指针变量和它所指向的内存是分开的概念，指针变量可以被赋值为其他地址。 以上内容仅是C语言提高讲义的部分要点，完整的讲义还可能涉及更深入的指针操作、...
C语言学习笔记.doc
03-14
以下是对C语言学习笔记的详细解析： 1. **第一个C程序**：C语言的每一个程序都始于`main()`函数，它是程序执行的起点。`#include "stdio.h"`是预处理指令，用于将标准输入输出库引入，`printf()`函数是输出函数，...
LeetCode //C - 343. Integer Break
Made in Code
09-05 396
【代码】LeetCode //C - 343. Integer Break。
C 标准库 - `＜float.h＞`
最新发布
wjs2024的博客
09-08 279
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
数据库有关c语言
T66656的博客
09-05 1289
SQL（Structured Query Language）是一种专门用来与数据库进行交互的编程语言，它允许用户查询、更新和管理关系型数据库中的数据。关系型数据库是基于表（Table）的数据库，其中表由行（Row）和列（Column）组成，每一行代表一个记录（Record），每一列代表一个字段（Field）。
C语言详细笔记--动态存储分配
Jasmine5606的博客
09-05 648
通过使用动态存储分配，程序员可以在函数执行部分的任何地方使用动态存储分配函数或者回收内存空间，从而有效地使用内存空间。功能：在内存的动态存储区中分配一块长度为size字节的连续内存空间。功能：释放p所指向的一块内存空间，p是指向的被释放空间的首地址，被释放的空间必须是由malloc()和calloc()函数所分配的。该程序段在内存中分配了5个连续的int型内存空间，并将其首地址赋给整形指针变量pa。举例：利用malloc()函数来动态生成数组。
"C语言基础-操作符详解：算数与移位操作符
C语言基础-操作符详解 一、引言 在C语言中，操作符是一种用来执行特定操作的标识符。操作符可以用于执行算术运算、逻辑运算...因此，读者在学习C语言时，务必要掌握这些操作符的使用规则，并灵活运用于实际的编程中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值