初识c语言（粗略带过c语言内容）

关于C语言

C语言是一门面向过程的计算机编程语言，与C++，Java等面向对象的编程语言有所不同。

底层开发

第一个C语言程序

#include <stdio.h> 

int main() 
{ 
    printf("hello bit\n"); 
    printf("he he\n"); 
    return 0; 

} 
//解释： 
//main函数是程序的入口 
//一个工程中main函数有且仅有一个 

数据类型

char        //字符数据类型
short       //短整型
int         //整形
long        //长整型
long long   //更长的整形
float       //单精度浮点数
double      //双精度浮点数

变量、常量

常量 - 不能改变的量

变量 - 能改变的量

int a = 5;//全局变量
int main()
{
	int a = 10;//局部变量
	printf("%d\n", a);//a=10 --> 当局部变量和全局变量名字冲突，局部优先
	return 0;
}

变量的使用

//求2个整数的和
//scanf函数是输入函数
//printf函数是输出函数
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;
    
    // %d -整型
	// %f -float型
	// %lf -double型
    // %s 打印字符串
}

注意：输入语句的报错

解决

变量的作用域和生命周期

作用域

1. 局部变量的作用域是变量所在的局部范围。

2. 全局变量的作用域是整个工程。

   //使用另一个源文件的全局变量需要、
   //声明一下变量
   extern int a;
   
   int main()
   {
   	printf("另一个文件的变量%d\n", a);//a的值
   
   	return 0;
   }
   

   不声明报错

生命周期

1. 局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

2. 全局变量的生命周期是：整个程序的生命周期。

常量

C语言中的常量分为以下以下几种：

• 字面常量

  3.14;
  'abd';
  

• const 修饰的常变量

   const float pai = 3.14f;   //这里的pai是const修饰的常变量
   pai = 5.14;//是不能直接修改的！
  

//注意
	int arr[10] = { 0 };
	const int n = 10;//虽然加了const 但n本质上还是变量
	int arr2[n] = { 0 };//这里的n只能放常量

• #define 定义的标识符常量

  	#define Max 10000
  	Max = 33232; //报错-->不能改
  
  	int n = Max;
  	printf("n = %d\n", n);//10000
  

• 枚举常量

4.枚举常量--可以一一列举的常量
	enum Sex
	{   //列出这种枚举类型的变量可能的取值
		//枚举常量
		NAN,
		NV = 3,//赋初值
		NOKNOW
	};

int main()
{
	enum Sex s = MALE;
	printf("%d\n", NAN);//0  枚举常量的默认是从0开始，依次向下递增1的
    MALE = 3; //报错-->不能改
	printf("%d\n", NV);//3
	printf("%d\n", NOKNOW);//4  
    
	return 0;
}

字符串+转义字符+注释

字符串

int main()
{
	char arr1[] = "hello";//按f10调试，发现存入第六个元素\0
    //字符串在结尾位置隐藏了\0，\0是字符串结束标志 
	char arr2[]= { 'h','e','l','l','o' };
	char arr3[]= { 'h','e','l','l','o'，'\0' };

	//%s 打印字符串
	printf("%s\n", arr1);//hello
	printf("%s\n", arr2);//hello后乱码 
    printf("%s\n", arr3);//hello

	//求字符串长度 strlen() -- string length
	int len = strlen ("hello");//len=5-----\0存在但不计算在长度上
	printf("%d\n", strlen(arr2));//随机值
	return 0; 
}

转义字符

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

 printf("%c\n", 'a');//a

笔试题

//程序输出什么？
#include <stdio.h>

int main()
{
    printf("%d\n", strlen("abcdef"));
    // \62被解析成一个转义字符
    printf("%d\n", strlen("c:\test\328\test.c"));//14-->8进制中没有8
    return 0; }

\ddd

选择语句

int main()
{
	int input = 0;//装输入的值
	printf("要好好学习吗?（1/0)");
	scanf("%d", &input);

	if (input == 1)
		printf("好offer\n");
	else
		printf("卖红薯\n");

	return 0;
}

循环语句

int main()
{
	int line = 0;
	while (line < 30000)
	{
		printf("写代码\n");
		line++;
	}
	if (line == 30000)
	{
		printf("好offer\n");
	}

	return 0;
}

函数

//两数相加
int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}

int main()
{
	int sum = Add(num1, num2);
	printf("%d", sum);
	return  0;
}

数组

数组定义

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

int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素
char ch[5] = {'a','b','c'};//不完全初始化，剩余的默认为0

数组的下标

数组的每个元素都有一个下标，下标是从0开始的。

数组可以通过下标来访问的

打印数组

int i = 0;
while (i < 10)
{
	printf("%d", arr[i]);
	i++
}

操作符

算术操作符

+ - * / %

int a = 9 / 2;//4
float a = 9 /2.0;//4.5000

移位操作符

右移操作符>>   左移操作符<<	移动的是二进制位

int main()
{
	int a = 2;
	int b = a << 1;
	printf("%d\n", b);//4
	return 0;
}

位操作符

& ^ |

赋值操作符

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

单目操作符(只有一个操作数)

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符) (类型)       强制类型转换

//sizeof
int main()
{   
	int arr[10] = { 0 };
	printf(" % d\n", sizeof(arr));//40 计算的是数组的总大小  单位字节
	printf(" % d\n", sizeof(arr[0]));//4 计算的是int类型大小
	//c语言 计算数组元素个数 方法
	int sz = sizeof(arr) / sizeof(arr[0]);//sz = 10

	return 0;
}

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

原理

按（二进制）位取反 把所有 二进制中数字，1变成0，0变成1

强制类型转换

int  a= (int)3.14;

关系操作符

>
>=
<
<=
!=   用于测试“不相等”
==      用于测试“相等”

逻辑操作符

&&     逻辑与
||     逻辑或

条件操作符

exp1 ? exp2 : exp3

逗号表达式

exp1, exp2, exp3, …expN

//逗号隔开的一串表达式
int main()
{
    int a = 0;
	int c = 5;
	int d = (a = b + 2, c = a - 4, b = c + 2);
    //d =3,从左向右依次计算,整个表达式的结果是最后一个表达式的结果
}    

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

[] () . ->

常见关键字

auto(自动)  break   case  char  const   continue  default(默认)  do   double else  enum   
extern(声明) float  for   goto  if   int   long 
register(寄存器)  return short  signed(有符号的)
sizeof   static struct  switch  typedef union(联合体)
unsigned(有符号的)   void  volatile  while

register(寄存器)

register int num = 100;//建议num的值存放在寄存器
//现在意义不大

计算机中数据可以存储在哪里呢

define - 是不是关键字？No-预处理指令
include - 是不是关键字？No-预处理指令

typedef 类型重定义

//typedef 类型重定义   别名
typedef unsigned int uint_32
{
    //观察num1和num2,这两个变量的类型是一样的
    unsigned int num1 = 0;
    uint_32 num2 = 0;
    return 0; }

关键字static

static 修饰局部变量 修饰全局变量 修饰函数

修饰局部变量

void test()
{
	static int a = 1;
	a++;
	printf("%d", a);  //加了static 2到11，不加10个2
//static修饰局部变量，改变了局部变量的生命周期1（本质上是改变了变量的存储类型）
}
int main()
{
	int i = 0;
	while(i < 10)
	{
		test();
		i++;
	}
	return 0;
}

原理

修饰全局变量

static修饰全局变量，使得这个全局变量只能在自己所在的源文件（.c）内部可以使用
全局变量，在其他源文件内部可以使用，是因为全局变量具有外部链接属性
但是被static修饰后，就变成了内部链接属性，其他源文件就不能链接到这个静态的全局变量了！(extern了也无用)

修饰函数

static修饰函数与修饰全局变量情况相同

常量和宏

define

1.define 定义常量  #define MAX 1000
2.define 定义宏
#define ADD(X,Y) X+Y//改成(（X)+(Y)）即可
int main()
{
	printf("%d\n", 4 * ADD(2, 3));//11  ADD(2, 3)会转换成2+3-->4*2+3
	return 0;
}

指针

内存

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

所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。

为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

取出地址

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

取出变量地址如下：

#include <stdio.h>
int main()
{
 int num = 10;
 &num;//取出num的地址
    //注：这里num的4个字节，每个字节都有地址，取出的是第一个字节的地址（较小的地址）
 printf("%p\n", &num);//打印地址，%p是以地址的形式打印
 return 0; }

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

int num = 10;
int *p = #//p为一个整形指针变量
*说明pa是指针变量
//	//int 说明pa执行的对象是int类型的

指针的使用实例：

#include <stdio.h>
int main()
{
 int num = 10;
 int *p = &num;
 *p = 20;//*解引用操作 *pa就是通过pa里面的地址找到a
  printf("%d\n", a);//a=20
    return 0; }

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

int main()
{
 char ch = 'w';
 char* pc = &ch;
 *pc = 'q';
 printf("%c\n", ch);
    return 0; }

指针变量的大小

#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; }

结论：指针大小在32位平台是4个字节，64位平台是8个字节。

结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包含： 名字+年龄+性别+学号 这几项信息。

这里只能使用结构体来描述了。

例如：

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

结构体的初始化：

int main()
{
	struct Stu s = { "张三",20, 85.5 };//结构体的创建和初始化
    //打印结构体信息
	printf("1: %s %d %lf\n", s.name, s.age, s.score);//结构体变量.成员变量  .为结构成员访问操作符
    
	//->操作符
	struct Stu* ps = &s;
	printf("2: %s %d %lf\n", (*ps).name, (*ps).age, (*ps).score);
	printf("3: %s %d %lf\n", ps->name, ps->age, ps->score);
	
	
	return 0;
}