burppp的C日志

初识C语言（浅浅地）

第一个C项目：

#include<stdio.h>
int main()
{
printf("helo c\n");
return 0;
}

总结：#include<stdio.h>称为头文件，顾名思义放在一段代码的开头

          int main()称为主函数，一段代码有且仅有一个主函数

          不要忘记在一行代码后加上“；”

          ctrl+f5运行程序

          输入代码的时候要用英文输入法，许多字符看似相同却无法运行

数据类型：整型/浮点型

          整型：整数；浮点型：小数。

 存储字符用单引号，如char ch='a'

 打印整数：%d

int main()
{
printf("%d\n",18)
return 0;
}

不同的数据类型或变量占有的空间不同

计算不同数据类型或变量所占空间的大小：sizeof（单位：字节byte）

 关于单位：最小单位bit是容纳一个二进制数字0/1所需要的空间，1byte = 8bit，往上还有kb、mb、tb、pb......以1024倍递增

变量与常量：

常量：不被改变的量；变量：能被改变的量

创建并改变变量：

#include<stdio.h>
int main()
{
	int age = 18;
	double weight = 65.3;
	age = age + 1;
	weight = weight - 0.5;
	printf("%d\n", age);
	printf("%lf\n", weight);

	return 0;
}

 

 整型用%d，double浮点型用%lf，float浮点型用%f

局部变量：{}之内定义的变量称为局部变量；全局变量：{}之外定义的变量称为全局变量

局部变量总优先于全局变量

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

 

 加法程序：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int sum = 0;
	scanf("%d %d", &a, &b);
	sum = a + b;
	printf("sum=%d\n", sum);

	return 0;
}

 总结：若vs想运行含scanf（）的代码须在开头加上#define _CRT_SECURE_NO_WARNINGS 1

           %d和%d须用空格隔开

           a和b前面的&不能漏

同样的，类似的程序能够实现四则运算

减法

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	scanf("%d %d", &a, &b);
	c = a - b;
	printf("c=%d\n", c);

	return 0;
}

 乘法：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	scanf("%d %d", &a, &b);
	c = a * b;
	printf("c=%d\n", c);

	return 0;

 除法：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	scanf("%d %d", &a, &b);
	c = a / b;
	printf("c=%d\n", c);

	return 0;
}

 求余：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	scanf("%d %d", &a, &b);
	c = a % b;
	printf("c=%d\n", c);

	return 0;
}

 

 数组：包含多个元素的集合

设置数组：int arr[元素个数]

元素在数组内的分布*：int arr[10]={1,2,3,4,5,6,7,8,9,10};数组内元素下标从0开始依次对应

求十个整数的最大值：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
//思路
//设置数组
//输入数组
//假设最大值
//比较大小
//得出最大值
{
	int arr[10] = {0};
	//数组初始化，方便下一行使用设置变量
	int i = 0;
	for (i = 0;i < 10;i++)
		//for(类似于数学中的定义域，可以理解为i属于[0，10）中的整数，变量变化过程为递增)
	{
		scanf("%d", &arr[i]);
		//&不能漏
	}
	int max = arr[0];
	for (i = 1;i < 10;i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	//若发现比arr[0]更大的元素即更新max
	printf("max=%d\n", max);
	return 0;
}

 

 在写代码前先列出//思路

for()括号内间隔用“；”

for循环语句：循环执行同一个操作，上图中两个for语句分别是循环输入数据和循环比较与arr[0]的大小

if判断语句：进行判断并依据结果执行不同的分支代码，上图中if语句是将比arr[0]大的数据更新max，若比arr[0]小则不做处理继续循环

求十个整数的平均数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
//设置数组
//输入数组
//数组求和
//求平均值
{
	int arr[10] = { 0 };
	int i = 0;
	int sum = 0;
	for (i = 0;i < 10;i++)
	{
 		scanf("%d", &arr[i]);
		sum = sum + arr[i];
	}
	double avg = sum / 10;
	printf("avg=%lf\n", avg);
	return 0;
}

 调试*：写好程序→f5→输入数据→菜单栏调试→窗口→监视→设置断点→输入监视的变量→执行程序→于断点处停止运行→f10逐步运行程序→看值有无发生意外变化。

变量：

全局变量的作用域：整个工程，阔文件引用变量时需要声明extern引用变量

局部变量的作用域：变量所在的局部范围

常量：

字面常量：12、a、abcd等；

const修饰的常变量：本质上是变量，但拥有常属性

#include<stdio.h>
int main()
{
    const int a=0;
    int arr[a]={0};
    return 0;
}

arr[]中只能是常量，被const修饰过的变量a放在arr[]中会报错，说明const修饰的常变量依然是变量

#define定义的标识符常量：

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
#define a 30
int main()
{
	printf("%d", a);
	return 0;
}

#define在主函数前后都可以，要注意格式，用空格间隔开，句末没有分号

枚举常量：

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
enum sex//枚举出可能的结果
{
	male,//注意逗号，不是分号
	female//没有分号
};//注意分号，在打出enum{}之后会自动给出分号，如果没有也要自己加上
int main()
{
	enum sex i = 0;//注意在枚举常量前有enum
	printf("%d\n", male);
	printf("%d", female);
	return 0;
}

一般默认不同的结果从下标0开始，如上图中没有male=，即默认male=0

字符串：

字符串用双引号，如"abcd"；单个字符用单引号，如'a'

数组：一组相同类型的元素

设置含字符串的数组：char arr[]="hello";

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	char arr1[] = "hello";
	char arr2[] = { 'h','e','l','l','o' };
	printf("%s\n", arr1);
	printf("%s", arr2);
	return 0;
}

 系统会在字符串末尾处加上\0，表示字符串的结束，故第一行打印出hello

但系统不会在数个单个字符末尾处加\0，printf读取内存不结束，故第二行打印出hello和乱码

/0占一个字节，在用sizeof计算两个数组所占空间是，字符串占6个字节，而后者占5个字节

 \0不计入字符串长度

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	char arr1[] = {"hehe"};
	printf("%d", strlen (arr1));//strlen求字符长度
	return 0;
}//打印出4

转义字符：

 三字母词总是会被解析成[]

printf要指定打印的类型，打印字符串用%s，打印字符用%c

认识八进制：C语言中，以反斜杠开头的是转义字符，转义字符后面可以跟8进制数来表示一个字符

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	printf("%c\n", '\105');
	return 0;
}

105（八进制）=5*8`0+0*8`1+1*8`2（十进制）=69（十进制）

 69对应ASCII表中的E，打印出E，ASCII表中每个字符都有对应的值

注释：C语言中有//和/**/，后者不支持嵌套注释

初识if选择语句：

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int coding = 0;
	printf("要不要好好学C？(1/0)\n");
	scanf("%d", &coding);//记得&
	if (coding == 1)//==才是等于
	{
		printf("小伙汁前途无量\n");
	}
	else
	{
		printf("去其他行业8\n");
	}
	return 0;
}

初识while循环语句：

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int i = 0;
	while (i < 15000)
	{
		printf("continue coding:%d\n",i);
		i++;//表明i递增，在符合条件时循环
	}
	if (i == 15000)
	{
		printf("finish coding\n");
	}
	return 0;
}

函数：

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
 float Add(float a,float b)//注意格式,Add()括号里最好再写一下变量类型
{
	float z = 0;
	z = a + b;
	return z;//注意
}
int main()
{
	float a, b, sum;
	scanf("%f%f", &a, &b);
	sum = Add(a, b);
	printf("sum=%f", sum);
	return 0;
}

这一类函数加法代码比前一类加法更长，但之后再做加法只需要引用Add函数即可

初识操作符：

算数操作符：+；-；*；/；%。%为求余

/除法中除数和被除数都是整数就执行整数除法，得出的结果向下取整

/除法中除数和被除数只要有一个是浮点数就执行浮点数除法，得出结果为浮点数

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 10 / 8;
	float b = 10.0 / 8;
	printf("%d\n", a);
	printf("%.2f",b );
	return 0;
}

打印出1和1.25

左移操作符：向左移动二进制位

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 9;
	//(十进制)9=（二进制）1001
	//变量a占有4个字节byte=32bit
	//a的二进制序列为00000000000000000000000000001001
	int b = a << 3;
	//b的二进制序列为00000000000000000000000001001000
	//（二进制）1001000=（十进制）2`6+2`3=72
	printf("%d", b);
	return 0;
}

位操作符：&按位与，|按位或，`按位异或

赋值操作符：=、+=、-=、*=、/=、&=、^=、|=、>>=、<<=

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 6;
	a += 5;//这一行相当于a=a+5；
	printf("%d", a);
	return 0;
}

单目操作符：只有一个操作对象的操作符

 ！：逻辑反操作

C语言中规定若0为假，若非0则为真，！将规则逆反

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 0;//a==0为假
	printf("%d", !a);//！变假为真，默认真为1，打印出1
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a;
	printf("猜猜今天会下雨吗?");
	scanf("%d", &a);
	if (a)//若a为真
	{
		printf("可能会");
	}
	if (!a)//若a为假，相当于else
	{
		printf("可能不会");
	}
	return 0;
}

sizeof：计算所占空间大小，其后()可省略

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int arr[10] = { 0 };//设置一个含有十个元素的数组
	printf("%d", sizeof arr/sizeof 0);//用数组所占的总空间除以一个元素所占的空间=数组内的元素个数
	return 0;
}

二进制的表示：原码、反码与补码

对于正整数，三种表示方法都与原码一样，如（十进制）15=1*2`3+1*2`2+1*2`1=（二进制）00000000000000000000000000001111

对于负整数，原码中最左边一位是1，表示负号，如（十进制）-6=-（1*2`2+1*2`1）=(二进制)10000000000000000000000000000011

原码-->反码，所有位0-->1,1-->0

（十进制）-6的反码：11111111111111111111111111111100

反码+1-->补码，（十进制）-6的补码：11111111111111111111111111111101

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

~：按二进制位取反，0-->1,1-->0

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
//求出0~1000所有整数的~a
int main()
{
	int a=0 ;
	
	while (a < 1000)
	{
		printf("%d\n", ~a);
		a++;
	}
	if(a==1000)
	{
		printf(".");
	}
	return 0;
}

 似乎总有~a=-（a+1）

前后置++：前置++先自加后使用，后置++先使用后自加

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 6;
	int b = ++a;
	//先自加，a=a+1
	printf("%d\n",a );
	printf("%d",b );
	//打印出7	7
	return 0;
}

define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 6;
	int b = a++;
	//先使用后自加
	printf("%d\n",a );
	//打印出7
	printf("%d",b );
	//打印出6
	return 0;
}

--与++类似

（类型）：强制转换类型（不常用）

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = (int)7.3;
	//相当于把浮点数纠正为整型，好像没啥用
	printf("%d", a);
	return 0;
}

关系操作符：

 逻辑操作符：

 &&：并且

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a, b;
	scanf("%d%d", &a, &b);
	int c = a && b;
	//a和b同为真，c才真；a或b为假，c为假
	printf("%d", c);
	return 0;
}

输入在一行中给出一个需要判断的整数N（100≤N≤999）。

如果N是三位数，按照以下格式输出：

152 = 个位数字 + 十位数字*10 + 百位数字*100

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int N;
	scanf("%d", &N);
	if (N >= 100 && N <= 999)
	//不能写作(100<=N<=999)
	{
		int a1, a2, a3;//百位数a1，十位数a2，个位数a3
		a1 = N / 100;
		a2 = (N % 100) / 10;
		a3 = (N % 100) % 10;
		//以后都可以按照这个方式求百位数、十位数、个位数
		printf("%d=%d*100+%d*10+%d*1", N, a1, a2, a3);
	}
	else
	{
		printf("Invalid Value.");
	}
	return 0;
}

||：或者，int c=a||b,a、b有一方为真，c为真

三目操作符

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
//求两个数的较大值
int main()
{
	int a, b, max;
	scanf("%d%d", &a,&b);
	max = a > b ? a : b;
	printf("max=%d", max);
	return 0;
}

可以在一定程度上取代if选择语句

逗号表达式：用逗号隔开的表达式，从左到右依次计算，整个表达式的结果是最后一个表达式的结果

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 2;
	int c = (b = a + 6, c = b - 2);//b=6-->c=4
	printf("%d", c);
	return 0;
}

 []：下标引用操作符，引用从零开始的第几个元素，如数组内用下标引用某个元素

():函数调用操作符，有函数就会有()

常见关键字：

 auto：自动的，每个局部变量都是auto修饰的，系统隐去auto，自动创建并销毁局部变量

break：跳出循环

char：字符类型

const：：常变量

default：默认

enum：枚举

extern：声明外部符号，引用其他源文件的函数或没有static修饰的全局变量

register：建议（大量频繁使用的数据）存放在寄存器中，系统可以自动识别并寄存一些常用数据

return：返回

(un)signed:有（无）符号的

static：静态的

1.修饰局部变量；

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
test()
{
	int a = 0;
	a++;
	printf("%d", a);
}
int main()
{
	int i=0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}
//打印出1111111111

在test()中a经历十次创建和销毁的过程，a=0，a++，打印出1111111111

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
test()
{
	static int a = 0;
	a++;
	printf("%d", a);
}
int main()
{
	int i=0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}
//打印出12345678910

static修饰的局部变量，经历一次创建和销毁，a=0，a++十次，打印出12345678910

可见static修饰局部变量可以改变局部变量的生命周期，本质上是改变了变量的存储类型

存储类型分三种：1.栈区（局部变量、函数参数...）、堆区（动态内存分配）、静态区（全局变量、static修饰的静态变量）

静态变量的生命周期等于全局变量的生命周期，延续至整个程序

2.修饰全局变量

全局变量的生命周期延续至整个程序，跨源文件引用全局变量要用extern声明外部符号

static修饰的全局变量使得该变量只能在它所在的源文件中被引用，extern不能声明被static修饰的全局变量

全局变量能在其他源文件中被使用是因为全局变量具有外部链接属性；被static修饰的全局变量，没有外部链接属性，而有内部链接属性。

3.修饰函数

同2，使用其他源文件的函数时用extern声明，在被static修饰之后不再被其他源文件引用，本质上仍然是static改变链接属性

struct：结构体

typedef：类型重定义

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
typedef unsigned int uint;
int main()
{
	uint a = 6;
	printf("%d", a);
	return 0;
}

union：联合体

void：无

#define和#include是预处理指令，不是关键字

#define定义符号和宏

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
#define a 6//在主函数前#define定义符号，注意格式
int main()
{
	printf("%d", a);
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
#define Add(x,y)(x+y)
//x+y最好用()括起来，否则可能会在计算顺序上出问题
int main()
{
	int a, b;
	scanf("%d%d", &a, &b);
	int sum = 3*Add(a, b);
	printf("%d", sum);
	return 0;
}

指针：

一个内存按一个字节分配地址

&取地址符，&取地址可以得到变量所在地址的起始位置

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
int main()
{
	int a = 1;
	printf("%p", &a);
	return 0;
}

通过地址在内存中找到a：F10-->调试-->窗口-->内存

结构体：C语言中创建新的类型

#define _CRT_SECURE_NO_WARNINGS 1;
#include<stdio.h>
struct stu
{
	int num;
	int age;
	float score;
};//注意分号
int main()
{
	struct stu s = { 40,18,93.1 };
	printf("%d %d %.1f\n", s.num, s.age, s.score);//结构体变量.成员变量
	struct stu* ps = &s;//指针指向结构体变量
	printf("%d %d %.1f\n", (*ps).num, (*ps).age, (*ps).score);//（指针）.成员变量
	printf("%d %d %.1f\n", ps->num, ps->age, ps->score);//另一种写法
	return 0;
}

->箭头操作符：结构体指针->成员变量