初识C语言(3)

操作符：

算数操作符：

+                                           加法

-                                            减法

*                                            乘法

/                                            除法

#include <stdio.h>
int main()
{
	int a = 7;
	int b = 2;
	//  7/2 = 3.5
	//由于a、b均为整型类型，因此得到的结果也为整型类型
	//所以小数点后的数字要去掉,结果为3
	int s = a / b;
	printf("%d\n", s);
	return 0;
}

#include <stdio.h>
int main()
{
	//当a、b为浮点型（小数）的时候，结果也为浮点数
	float a = 7.2f;
	float b = 2.0f;
	//  7.2/2 = 3.6
	float ret = a / b;
	printf("%f\n", ret);
	return 0;
}

%                                          取余数

#include <stdio.h>
int main()
{
	int a = 7;
	int b = 2;
	//  7/2 = 3......1
	//得三余一
	int s = a % b;
	printf("%d\n", s);
	return 0;
}

位移操作符：

>>                                          右移操作符

<<                                          左移操作符

位操作符：

&                                           按位与

|                                            按位或

^                                           按位异或

单目操作符：

！                                        逻辑反操作符

#include <stdio.h>
int main()
{
	int a = 1;
	if (a)                 //非0 为真
	{
		printf("YES");
	}
	if (!a)                //逻辑反 变为 假
	{
		printf("NO");
	}
	return 0;
}

+                                          正号

-                                           负号

&                                          取地址                （后面会讲）

~                                          对一个数的二进制按位取反 （后面会讲）

*                                           间接访问操作符(解引用操作符)         （后面会讲）

(类型)                                   强制类型转换

#include <stdio.h>
int mian()
{
    //int     double
    //int a = 3.14//err  3.14为浮点型，而a的类型为整型
    int a = (int)3.14;   //将3.14强制类型转化为整型类型，符合b的类型
    printf("%d\n",a); //3
    return 0;
}

sizeof                                    操作数的类型长度(以字节为单位)

#include <stdio.h>
int mian()
{
    int a = 0;
    printf("%d\n",sizeof(a));     //4
    printf("%d\n",sizeof(int));   //4
    int arr[10] = {0};
    printf("%d\n",sizeof(arr));   //40
    printf("%d\n",sizeof(arr[0]));//4
    //求数组中元素的个数
    int sz = sizeof(arr)/sizeof(arr[0]);   //  40/4 = 10个元素
    return 0;
}

strlen与sizeof的比较：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr1[] = "abc";
    char arr2[] = {'a','b','c'};
    
    printf("%d\n",sizeof(arr1));  //4
    printf("%d\n",sizeof(arr2));  //3
    //sizeof 在这里计算数组的大小，即数组中含有几个元素
    //其中"abc"实际上在最后还有一个'\0' 来作为字符串的结束标志
    //也计算到内，因此，sizeof(arr1) 的大小为4个字节
    
    printf("%d\n",strlen(arr1));  //3
    printf("%d\n",strlen(arr2));  //随机值
    //strlen 为库函数，用来计算字符串的长度，以 '\0' 为结束标志
    //"abc"后紧跟这一个'\0'，所以strlen(arr1) 的大小为3
    // 而{'a','b','c'} 初始化的数组结尾不会自动补'\0',
    // 因此，strlen就会一直向后找，直到找到'\0'为止，为随机值
    
    return 0;
}

前置、后置++  与   前置、后置--

#include <stdio.h>
int main()
{
    int a1 = 10;
    
    int b = ++a1;//前置++，先++，再使用
    //b=a1+1,a1=a1
    printf("%d %d\n",a1,b);  //11 11
    
    int a2 = 10;
    int c = a2++;//后置++，先使用，后++
    //c=a2,a2=a2+1
    printf("%d %d\n",a2,c);  //11 10
    
    int a3 = 10;
    int d = --a3;//前置--，先--，再使用
    //d=a3-1,a3=a3
    printf("%d %d\n",a3,d);  //9 9
    
    int a4 = 10;
    int e = a4--;//后置--，先使用，再--
    //e=a4,a4=a4-1
    printf("%d %d\n",a4,e);  //9 10
    
    return 0;
}

赋值操作符：

=

+=

#include <stdio.h>
int main()
{
	int a = 2;
	a += 3;
	//a+=3  即为  a=a+3
	printf("%d\n", a); //5
	return 0;
}

        以下同理！！！ 

-=

*=

/=

&=

^=

|=

>>=

<<=

关系操作符：

>

>=

<

<=

!=                                                       （用于测试"不相等")

==                                                        (用于测试"相等")

逻辑操作符：

&&                                                        逻辑与(并且)

||                                                           逻辑或(或者)

if(18<=age<=35)//err
if(age>=18 && age<=35)//right

条件操作符(三目操作符)：

exp1  ?   exp2  :  exp3

看exp1 是否符合条件，符合条件返回exp2, 否则返回exp3

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	//输出a、b中的较大值
	int ret = a > b ? a : b;
	printf("%d\n", ret);
	return 0;
}

逗号表达式:

exp1,exp2,exp3,...expn

逗号表达式从左往右计算，最后的结果由最后一个表达式决定！！！

#include <stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	int ret = (a += 2, b += 1, c += 3, a += b, c + a + b);
	//           a=2     b=1     c=3     a=3       7
	printf("%d\n", ret);//7
	return 0;
}

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

[]

()

.                      (后面会讲)

->                   (后面会讲)

常见关键字：

auto 自动

break 停止

char

int

short

long

long long

flaot

double

const

continue 继续

default

case

enum 自定义类型 （枚举

extern

for

do while

goto

if else

register 寄存器关键字

return

signed 有符号的

unsigned 无符号的

sizeof

static

   用来修饰变量和函数的

1. 修饰局部变量：称为静态局部变量

    static 修饰的局部变量改变了变量的生命周期，让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。

     2. 修饰全局变量：称为静态全局变量

    static 修饰的全局变量只能在本源文件中使用，不能在其他源文件中使用。

     3. 修饰函数：称为静态函数

    static 修饰的函数只能在本源文件中使用，不能在其他源文件中使用。

typedef       类型重命名

//将unsigned int 重命名为uint_32, 所以uint_32也是一个类型名
typedef unsigned int uint_32;
int main()
{
    //观察num1和num2，这两个变量的类型是一样的
    unsigned int num1 = 0;
    uint_32 num2 = 0;
    return 0;
}

struct 

switch

volatile

union

内存分配：

栈区：局部变量，函数的参数

堆区：动态内存分配，

静态区：静态变量，全局变量