C语言笔记-2

八.字符串+转义字符

字符串

就是一串字符，用""(English)双引号引起来。

字符串的结束标志是\0。

空格" "也算一个字符。

如果使用一个一个的字符来组成字符串，则没有\0

#include<stdio.h>

int main()
{
	char h[] = "Hello Word";
	char h2[] = { 'H','e','l','l','o',' ','W','o','r','d' };
	printf("%s", h);

	return 0;
}

 第二行输出因为没有结束符标志，所以出现乱码。

转义字符​

转变了其原本的意思

通常格式：\字符。

转义字符	释义
\?	在连续多个问号时，防止他们被解析为三字母词（vs2019已不支持三字母词）
\'	用于表示字符常量’
\"	用于表示一个字符串内部的双引号
\\	用于表示一个反斜杠，防止它被解析为一个转义序列符
\a	警告符号，使计算机发出蜂鸣
\b	退格符
\f	进制符
\n	换行
\r	回车
\t	水平制表符
\v	垂直制表符
\ddd	ddd表示1-3个八进制的数字。如\130 X
\xdd	dd表示2个十六进制数字。如：\x30 0

注释

两种注释方法

//        只能在单行注释，写在注释开头

/**/       不限制换行，写在注释开头和结尾

#include<stdio.h>
int main()
{
    printf("这里不是注释");//这里是一段注释
    /*这里也是一段注释*/
    //双斜杠注释只能注释一行
    /*斜杠加星号注释由（/+*）开始（*+/）结束
    不限制换行*/

    return 0；
}

初步了解

初识选择语句

        if……else语句

#include<stdio.h>
int main()
{
    int input=0;
    printf("输入(0/1)?：");
    scanf("%d",&input);
    if(input=0)
    {
        printf("input=0");
    }
    else if(input=1)
    {
        printf("input=1");
    }
    else
    {
        printf("禁止涩涩！");
    }   

    return 0;

}

通过if……else语句判断并运行代码块的内容，如果需要多种判断情况，可以在中间使用else if。

初识循环语句

创建循环结构，加入判断，是则跳出循环，否则继续循环。

while()

{

}

#include<stdio.h>

int main()
{
    int a=0,b=0;
    scanf("%d",&b);
    whlie(int i<b)
    {
        printf("a=%d\n",a)
        a++;//等效于a=a+1
    }

    return 0;
}

for(;;)

{

}

初识函数和数组

函数

 与数学函数相似，可以理解为一个方法。

#include<stdio.h>

int main()
{
    int num_1=0;
    int num_2=0;
    scanf("%d%d",$num_1,&num_2);
    
    printf("%d\n",add(num_1,num_2));

    return 0;
    
    
}

void add(int a,int b)
{
    return a+b;
}

函数需要运用参数来传递值。 

数组

一组相同类型的元素的集合

int main()
{

	int a_1[10] = { 1,2,3,4,5,6,7,8,9,10 };//整型数组
	char c[5] = { 'a','b','c' };//剩余的默认为0
	return 0;


}

 数组的下标是从0开始。

数组是通过下标访问的。

打印数组：通过循环语句，对下标进行自增加1来遍历数组。

#include<stdio.h>

int main()
{
    int a[10]={1,2,3,9,8,7,4,5,6,10}

    for(int i=0;i<10;i++)
    {
        printf("%d",a[i]);//通过i的自增，来遍历数组，添加条件使i最大值不会超出数组。
    }
    return 0;
}

初识操作符

算术操作符

+ - * / %        //*就是乘号

当除号两端，都是整数，结果也是整数

#include<stdio.h>

int main()
{
    float a=9/4;
    float b=9/4.0;
    printf("%f    %f",a,b);

    return 0;
}

 %：取模（取余）

移位操作符：>> <<

操作符移动的是二进制位。

#include<stdio.h>

int main()
{
    int b=2;
    int a=b<<1

    printf("%d",a);

    return 0;
}

计算机中的值以二进制存储再内存中，这里2在内存的的存储内容为

//整型是4个字节，一个字节8bt，所以一个整型一共32bt位

[00000000000000000000000000000010]

这是2这个整型在内存中的二进制表达格式。<<位移动则是将其整体向左移动，这里移动了一位

0[0000000000000000000000000000010 ]

最左边的0移出了这个整型的内存空间范围，排除，右侧空了一个bt位，补上0，则为

[00000000000000000000000000000100]

然后得到上述二进制，其十进制值为4

 总体来说，就是a的二进制格式*10^位移值

位操作符

&        按位与

|        按位或

^        按位异或

赋值操作符

=        +=        -=        *=        ^=        |=        >>=        <<=

#include<stdio.h>

int main()
{
    int a=2;
    int b=0;
    int c=0;
    
    b=b+a;
    c+=a;

    printf("%d\t%d",b,c);

    return 0;
}

单目操作符

！	逻辑反操作（非）
-	负值
+	正值
&	取地址
sizeof	操作数的类型长度（/bt）
~	对一个数的二进制按位取反
--	前置、后置--（自减）
++	前置、后置++（自增*）
*	间接访问操作符（解引用操作符）
（类型）	强制类型转换

C语言中，0为假，非0为真，（!任意非0）=0,!0=1。对0使用逻辑反操作！时，默认结果为1

a+b，这里的+时双目操作符，单目操作符指只有一个操作数：+a。

~        按（二进制位取反）

(把所有二进制位中的数字，0变成1，1变成0)

#include<stdio.h>

int main()
{
    int a=0;
    printf("%d",~a);

    return 0;
}

这里0的二进制:00000000000000000000000000000000

~0：11111111111111111111111111111111

整数在内存中存储的是补码。

一个整数的二进制表示有三种：原码，反码，补码。

-1的原码：1[00000000000000000000000000000001]

{1的原码：00000000000000000000000000000001，

所以-的原码：100000000000000000000000000000000}

      反码：1[11111111111111111111111111111110]       

反码+1就是补码：1[11111111111111111111111111111111]        

注意，这里的[]表示四个字节，也就是32bt，[]本身不存在，只是为了方便区分

初识常量关键字

特点：

 C语言提供的关键字

不能自创关键字

关键字不能作为变量        int int=1;

auto	break	case	char	const	contine	default	do	double
else	enum	extern	float	for	goto	if	int	long
register	return	short	signed	sizeof	static	struct	swich	typedaf
union	unsigned	void	volatile	while

auto(自动的)        每个局部变量都是auto修饰的        基本上都会省略掉

#include<stdio.h>

int main()
{
    {
        auto int a=10;
    }//自动创建并销毁

    return 0;
}

新的C语言语法中有其他语法……

break:跳出循环

extern 用来申明外部符号

register 寄存器关键字

#include <stdio.h>
int main()
{
    register int num=100;//建议num的值存放在寄存器中
    //只是建议，但是否存储在寄存器中由编译器说了算
    
    return 0;
}

计算机中，数据存放在：网盘、硬盘、内存、高速缓存、寄存器。

从左到右，读写空间逐渐减小，读写速度逐渐增大。

所以，寄存器是计算机中读写最快的存储空间。

//大量，频繁，被使用的数据，放在寄存器中，可以提升效率

//但现如今的编译器会自动判断数据是否需要存储在寄存器中，所以这个关键字没必要了。

signed        有符号的（正负）

unsigned     无符号的

static           静态的

struct          结构体

union         联合体（公用体）

void              无

define和include都不是关键字，其为预处理指令

typedef         类型重定义        //让类型变得更简单

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

int main()
{
	unsigned int num_1 = 10;
	u_int num_2 = 20;
	printf("%d\t%d", num_1, num_2);
	return 0;

}

在这里，重新将unsigned int这里两个关键字组合，并让u_int作为这个组合的别名，并不影响这个组合。

static        静态的       

1. 修饰局部变量

#include<stdio.h>

int main()
{
	int i = 0;
	while (i < 10)
	{
		{
			static b = 0;
			//static对b进行定义，它替换了被省略的auto，
			//没有了自动创建和自动销毁。所以他的值被保留了下来。
			int a = 0;
			a++;
			b++;
			printf("%d\t%d\n", a, b);
		}
		i++;
	}
	return 0;
}

 改变了局部变量的生命周期(本质上是改变了变量的存储类型)。 

//将被修饰的变量由栈区移到静态区

1. 修饰全局变量

static 修饰的全局变量只能在自己所在的源文件（.c）内部使用。

1.c

int num_1=1;
static int num_2=2;

2.c

#include<stdio.h>

static unt num_3=3;
extern int num_1;
extern int num_2;
int main()
{
   // printf("%d\n%d\n%d",num_1,num_2,num_3);    这里会报错
    printf("%d\n%d",num_1,num_3);

    return 0;
}

 这里显示num_2属于无法解析的外部符号。

 全局变量具有外部链接属性，这里被static修饰后，外部链接属性变成了内部链接属性。

1. 修饰函数

和修饰全局变量一样的属性

int add(int a, int b) {
	int num = a + b;
	return num;
}
static int subtract_1(int a, int b)
{
	return a - b;
}
int subtract_2(int a, int b)
{
	return a - b;
}

#include<stdio.h>

extern add(int a, int b);
extern subtract_1(int a, int b);//这里被static修饰
extern subtract_2(int a, int b);

//同全局变量一样，函数想要跨文件使用也需要extern来声明
int main()
{
	int a = 5;
	int b = 6;

	int num_a = add(a, b);
	//int num_s_1 = subtract(a, b);
	int num_s_2 = subtract_2(a, b);
	//因为函数被static定义，没有了外部链接属性，所以这里找不到对应函数并报错
	//printf("num_a=%d\nnum_s_1%d\nnum_s_2", num_a, num_s_1,num_s_2);
	printf("num_a=%d\nnum_s_2=%d", num_a, num_s_2);
	return 0;
}

 其本质和修饰全局变量一样，都是外部链接属性被改为了内部链接属性。