操作符详解:
-
/与%
/：除号两端如果都是整数，执行的是整数除法，除号两端不限制必须是整数；除号的两端至少有一个数是浮点数，才能执行浮点数的除法。
%：取模（取余），%操作的两个操作数必须是整数。
具体实现如下：
#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 = #指针的使用实例：
#include <stdio.h>
int main()
{
int num = 10;
int *p = #
*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);
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
