初识C语言（3）

最新推荐文章于 2024-02-14 12:41:51 发布

原创最新推荐文章于 2024-02-14 12:41:51 发布 · 407 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #开发语言

本文详细介绍了C语言中的算术操作符，如整数除法和取模，以及它们对整数和浮点数的应用。还讨论了浮点数除法、强制类型转换、指针的概念以及如何通过指针操作变量。此外，提到了结构体在描述复杂数据类型中的作用，包括结构体的初始化和成员访问。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

操作符详解:

/与%

/：除号两端如果都是整数，执行的是整数除法，除号两端不限制必须是整数；除号的两端至少有一个数是浮点数，才能执行浮点数的除法。

%：取模（取余），%操作的两个操作数必须是整数。

具体实现如下：

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

	//float类型的数据，使用%f打印
	//double类型的数据，使用%lf打印

	float num = 10.0f;
	printf("%f\n", num/4);
	printf("%f\n", num / 4.0);
	//printf("%f\n", num % 4);       //错误！！！%取模两边不能出现浮点型
	
	//保留两位小数
	printf("%.2f\n", num / 4);
	printf("%.2f\n", num / 4.0);
	return 0;
}

运行结果如下：

赋值操作符

#include<stdio.h>
//int main()
//{
//	int a = 0;//初始化，创建变量的同时给一个值，这叫初始化
//	a = 20;//赋值
//
//	a = a + 5;
//	a += 5;
//
//	a = a * 10;
//	a *= 10;
//
//	return 0;
//}
//

//真假
//C语言中
//0就是假
//非0表示真

#include<stdio.h>
//int main()
//{
//	int flag = 5;
//
//	//如果flag为真，就打印hehe
//	if (flag)
//	{
//		printf("hehe\n");
//	}
//	//
//	if (!flag)
//	{
//		printf("haha\n");
//	}
//	return 0;
//}
//

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

单目操作符
sizeof是操作符，是计算变量所占内存空间的大小，单位是字节
strlen是库函数，是计算字符串的长度的，统计的是字符串中\0之前出现的字符个数

#include<stdio.h>
int main()
{
	int a = 10;
	float f = 5.5f;

	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	
	printf("%d\n", sizeof(f));
	printf("%d\n", sizeof(float));
	return 0;
}

++、-- ，代码演示如下：

#include<stdio.h>
int main()
{
	int a = 100;
	int b = (a++);//后置++，先使用，后++
	int b = a, a = a + 1;

	int b = ++a;//前置++，先++，后使用
	a = a + 1, b = a;

	int b = a--;
	int b = a, a = a - 1;

	int b = --a;
	a = a - 1, b = a;
	printf("a=%d b=%d\n", a, b);

	return 0;
}

（类型）-----------强制类型转换

代码演示如下：

//int main()
//{
//	//(类型) - 强制类型转换
//	int a = (int)3.14;//这里只取整数部分
//	printf("%d\n", a);
//
//	return 0;
//}

#include<stdio.h>
//int main()
//{
//	int a = 3;
//	if (a = 5)
//	{
//		printf("hehe\n");
//	}
//
//	return 0;
//}
//
//int main()
//{
//	//年龄18~36 青年
//	int age = 2;
//	if (18 <= age <= 36)
//		printf("青年\n");
//
//	//if (age >= 18 && age <= 36)
//	//	printf("青年\n");
//
//	//&& || 只关注真假
//	//&& 两边同时为真，才为真
//	//|| 两边同时为假，才为假
//
//	//int a = 0;
//	//int b = 0;
//	//if (a || b)
//	//	printf("haha\n");
//
//	//if (a && b)
//	//{
//	//	printf("hehe\n");
//	//}
//	return 0;
//}

//int main()
//{
//	int arr[10] = {1,2,3,4,5,6,7,8,9,0};
//	printf("%d\n", arr[4]);//[]下标引用操作符
//
//	return 0;
//}

补充上节C语言关键字内容：

表示类型的有：auto,char,int ,short,long ,long long,float,double,signed(有符号),unsigned(无符号),static,const,enum,union，struct，void，
表示循环的有：break，continue，do，while，for
分支语句中有：if.....else，switch，case，default，goto
extern：声明外部符号
register：寄存器
sizeof：计算所占内存大小的
return：在函数中应用

1.关键字scanf-----------输入函数

代码演示如下：

#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;

	//scanf函数读取失败的时候回返回EOF-----转到定义EOF表示-1
	// 
	//scanf读取正常的话，返回的是读到的有效数字个数！！！
	//此时只读到a的值，所以ret肯定为1
	int ret = scanf("%d", &a);
	printf("%d\n", ret);


	printf("a = %d\n", a);
	printf("b = %d\n", b);
	return 0;
}

2.关键字register------------寄存器

代码演示如下：

#include<stdio.h>
int main()
{
    int a=10;
    //寄存器
    //寄存器中存储的数据会更快的被计算机处理
    register int a=10;
    return 0;
}

那么，在计算机上，数据可以存储在哪里呢？

3.关键字typedef

typedef 顾名思义是类型定义，这里应该理解为类型重命名。

代码演示如下：

#include<stdio.h>
typedef unsigned int Int;

int main()
{
	unsigned int a = 20;
	printf("%d\n", a);

	Int b = 90;
	printf("%d\n", b);
	return 0;
}

4.关键字static

在C语言中：static是用来修饰变量和函数的

修饰局部变量-称为静态局部变量
修饰全局变量-称为静态全局变量
修饰函数-称为静态函数

1、修饰局部变量

代码演示如下：

#include<stdio.h>
//修饰局部变量
//代码1
void test()
{
	int a = 0;
	a++;
	printf("%d\n", a);
}
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}

//代码2
void test()
{
	static int a = 0;
	a++;
	printf("%d\n", a);
}
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}

运行结果如下：

代码1：

代码2：

总结：

普通的局部变量是放在栈区上的，这种局部变量进入作用域创建，出了作用域释放，但是局部变量被static修饰后，这种变量就放在静态区，放在静态区的变量，创建好后，直到程序结束才释放本质上：static的修饰改变了局部变量的存储位置，因为存储位置的差异，使得执行效果不一样。被static修饰是不影响作用域的！！！！！但是生命周期发生了变化，变长了。

那么数据在内存中是怎样存放的呢？

2、修饰全局变量

代码演示如下：

//重新创建一个文件：add.c文件

#include<stdio.h>
//修饰全局变量:
// 


//int g_val=20;
static int a_val=20;

#include<stdio.h>
//修饰全局变量:
// 
//声明外部符号
//extern int g_val;
//int main()
//{
//	printf("%d\n", g_val);
//	return 0;
//}
//

运行代码如下：

总结：

全局变量本事是具有外部链接属性的，在A文件中定义的变量，在B文件中可以通过【链接】使用，但是如果全局变量被static修饰时，这个外部链接属性就变成了内部链接属性，这个全局变量只能在自己所在的源文件内部使用。static的修饰，会把外部链接属性编程内部链接属性，最终使得全局变量的作用域变小了。

3、修饰函数

代码演示如下：

//重新创建一个文件：add.c文件

#include<stdio.h>
//修饰函数:
// 
//int MAX1(int x, int y)
//{
//	return(x > y ? x : y);
//}
//
//static int MAX(int x, int y)
//{
//	return(x > y ? x : y);
//}

//声明外部函数
#include<stdio.h>
extern int MAX(int x, int y);
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d%d", &a, &b);
	int ret = MAX(a, b);
	printf("%d\n", ret);
	return 0;
}

总结：

函数本身是具有外部链接属性的，被static修饰后，外部链接属性就变成了内部链接属性
使得这个函数只能在自己所在的源文件内部使用，别人不能使用也看不见，其他源文件无法使用
#include<add.c> ------ 错误的！！！；头文件：包含类型的定义，头文件的包含，函数的声明

12.#defne定义常量和宏

代码演示如下：

//define 定义宏/定义符号     M是一个符号不是变量
//#define M 100
//int MAX(int x, int y)
//{
//	/*if (x > y)
//		return x;
//	else
//		return y;*/
//	return (x > y ? x : y);
//}
//

//#define MAX(x,y) (x>y?x:y)
//#define ADD(x,y)  ((x)+(y))
//
//int main()
//{
//	int ret = MAX(2, 3);
//	int ret1 = ADD(1, 2);
//	printf("%d\n", ret);
//	printf("%d\n", ret1);
//	return 0;
//}

13.指针

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的。

内存时计算机上的一种存储空间分有8G/16G，程序运行的时候回载入内存，程序中如果有数据需要存储，也会申请内存空间。

为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地
址。

在32位机器下，会有32根地址线，地址线存放的时2进制序列，从序列00000000000000000000000000000000，一直到序列11111111111111111111111111111111代表内存单元的地址，会产生2^32次方个二进制序列，就可以作为2^32个内存单元，就可以管理2^32个内存单元，也就是2^32个字节的内存空间。补充：1Byte=8bit；1KB=1024B；1MB=1024MB；1GB=1024MB;

变量是创建内存中的（在内存中分配空间的），每个内存单元都有地址，所以变量也是有地址的。取出变量地址代码如下：

// 
//int main()
//{
//	int a = 1;
//	int* pa = &a;
//	*pa = 20;//解引用操作 - 作用就是通过pa中的地址，找到a, *pa就是a
//	//a=20;

	/*printf("%d\n", a);

	printf("%p\n", &a);
	printf("%p\n", pa);*/
	//	//pa是一个变量，这个变量是用来存放地址的
	//	//而地址又叫指针
	//	//所以在C语言中把pa叫指针变量（指针变量是存放指针的变量）
	//	// 
	//	// 
	//	//&a;//& 取地址操作符
	//	//printf("%p\n", &a);
	//	//&a 取出的是a所占内存的4个字节中第一个字节的地址
	//	
	//	//printf("%d\n", sizeof(a));
	//		
	//	return 0;
	//}

那地址如何存储，需要定义指针变量。

int num = 10;
int *p;//p为一个整形指针变量
p = &num;

指针的使用实例：

#include <stdio.h>
int main()
{
int num = 10;
int *p = &num;
*p = 20;
  return 0;
}

以整形指针举例，可以推广到其他类型，如：

#include <stdio.h>
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'q';
printf("%c\n", ch);
  return 0;
}

13.2指针变量的大小

#include <stdio.h>
//指针变量的大小取决于地址的大小
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
  printf("%d\n", sizeof(char *));
  printf("%d\n", sizeof(short *));
  printf("%d\n", sizeof(int *));
  printf("%d\n", sizeof(double *));
  return 0;
}

14.结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。
比如描述学生，学生包含：名字+年龄+性别+学号这几项信息。
这里只能使用结构体来描述了。

例如：

struct Stu
{
  char name[20];//名字
  int age;    //年龄
  char sex[5];  //性别
  char id[15]； //学号
};

结构体的初始化：

//打印结构体信息
struct Stu s = {"张三"， 20， "男"， "20180101"};
//.为结构成员访问操作符
printf("name = %s age = %d sex = %s id = %s\n", s.name, s.age, s.sex, s.id);
//->操作符
struct Stu *ps = &s;
printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps-
>id);