C语言学习 （主要内容简要整理）

打印的类型

%d   整形

%f    float

%lf    double

%p  以地址的类型打印

数据类型

char   1

short int（short）2

long int(long)   4

long long    8

float    4

double(精度比单精度高）    8

 每种字型长度

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    int A = 2;
    printf("%d\n",A);
    printf("%o\n", A);
    printf("hello world!\n");
    printf("%d\n",sizeof (double));
    printf("%d\n",sizeof (float));
    printf("%d\n",sizeof (long long));
    printf("%d\n",sizeof (long));
    printf("%d\n",sizeof (short));
    printf("%d\n",sizeof (char));
    printf("%d\n",sizeof (int));
    return 0;

}

不同的类型拥有不同的字节位；

数据类型是用来创建变量的，变量定义时需要定义它的数据类型；根据数据类型创建不同的变量，数据长度短的创建短的变量，用来节约空间。

不同的变量大小是用来放置合适的空间的。

变量、常量

常量：不可以改变的量

变量：可以改变的量

int age=23；

float weight=150.2；

char xingming=‘why’；

创建一个变量

类型  变量的名字=0（初始化值）；

类型  变量的名字；

变量的分类

局部变量

函数内定义的变量，只在{}内生效；只作用在局部范围之内；

全局变量

 定义在{}外，在{}全局生效；在整个工程内适用。

局部变量和全局变量名字尽量不要相同，如果存在相同的名字，局部变量优先。

常量

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

例如10，666属于字面商量；

加const将变量修饰成常变量，具有常量属性，本质属于变量 ,int shuzu[ ]中[ ]里面不能放常变量；

#define定义的标识符常量，define定义的常量可以放在 int shuzu[ ]；

枚举常量 ，用enum定义。

scanf解决办法

scanf是输入函数（输入数据时使用）；

&取地址符号，将输入的值放入&后边的地址中；

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

C语言规定，变量要定义在当前代码块的最前面。

字符串+转义字符+注释

字符串

#include <stdio.h>
int main()
{
	char arr1[] = "abc";
	char arr2[] = { 'a', 'b', 'c' };
	printf("%s\n",arr1 );
	printf("%s\n",arr2);
	return 0;

}

字符串的结束标志是一个 \0 的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串 内容。

转义字符

"\"转换原来的意思

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

数组

数组定义

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//定义一个整形数组，最多放10个元素

数组的下标

C语言规定：数组的每个元素都有一个下标，下标是从0开始的。

int arr[10] = {0};
//如果数组10个元素，下标的范围是0-9

数组的使用

#include <stdio.h>

int main()
{
	int i = 0;
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

操作符

算术操作符

+ - * / %(取余)

移位操作符

>>   <<

位操作符

& ^ |

赋值操作符

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

单目操作符

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

关系操作符

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

逻辑操作符

&&     逻辑与 ||          逻辑或

条件操作符

exp1 ? exp2 : exp3

逗号表达式

exp1, exp2, exp3, …expN

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

[] () . ->

常见的关键字

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

typedef

typedef 是类型定义，或者是类型重命名。

#include<stdio.h>
typedef unsigned int uint_32;
int  main()
{
	unsigned int num1 = 0;
	uint_32 num2 = 0;
	return 0;
}

static

修饰局部变量

代码1
//void test()
//{
//	static int i = 0;
//	i++;
//	printf("%d\n", i);
//}
//
//int main()
//{
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		test();
//
//	}
//	return 0;
//}
//代码2
//void test()
//{
//	int i = 0;
//	i++;
//	printf("%d\n", i);
//}
//
//int main()
//{
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		test();
//
//	}
//	return 0;
//}

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

修饰全局变量

//代码1
//test.c
int date = 2022;
//pritice.c
int main()
{
	extern int date;
	printf("date=%d\n", date);
	return 0;
}
//代码2
//test.c
static int date = 2022;
//pritice.c
int main()
{
	extern int date;
	printf("date=%d\n", date);
	return 0;
}

现象：代码1正常，代码2报错。

static修饰全局变量：改变了变量的作用域-让静态的全局变量只能在自己所在的源文件内部使用出了源文件就没法再使用了；

//代码1
//add.c
int Add(int x, int y)
{
    return c+y;
}
//test.c
int main()
{
    int Add; 
    printf("%d\n", Add(2, 3));
    return 0;
}
//代码2
//add.c
static int Add(int x, int y)
{
    return c+y;
}
//test.c
int main()
{
    int Add; 
    printf("%d\n", Add(2, 3));
    return 0;
}

现象：代码1正常，代码2报错。

static修饰函数

改变了函数的作用域；static修饰函数改变了函数的链接属性，正常的函数具有外部链接属性，经过static修饰后变成内部链接属性。

extern 

extern声明外部符号：让声明的变量在源文件外部可以使用。

define

#define定义标识符常量；

#define定义宏。

指针

  内存与指针

为了有效的利用电脑中的内存，就把内存划分成好多个小的存储单元，每个存储单元大概是一个字节，为了有效访问每个存储单元，就把每个存储单元进行编址，每个单元内存都有地址。变量是创建在内存单元中的，所以变量也是有地址的。

int main()
{
	int num = 0;
	#//&为取地址符
	printf("%p\n", &num);//%p,以地址的形式打印
	return 0;
}

为了存储地址就需要定义指针变量

int main()
{
	int num = 0;
	int* p = #
	p = #
	printf("%p\n", p);
	return 0;
}

指针变量的大小

指针大小在32位（32bit）平台是4字节，在64位（64bit）平台是8字节。

特别注意

int main()
{
	printf("%d\n", sizeof(char*));
	printf("%d\n", sizeof(int*));
	printf("%d\n", sizeof(double*));
	printf("%d\n", sizeof(float*));
	printf("%d\n", sizeof(short*));
}

显示结果全部为8。

指针变量学习留下的疑问：指针的实际用处与意义是什么？

结构体 

struct Stu
{
    char name[20];//名字
    int age;      //年龄
    char sex[5];  //性别
    char id[15]; //学号
};
int main()
{
    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);
    return 0;
}

修改结构体中数组的内容时用strcpy（string copy）字符串拷贝，还需要引用库函数——string.h

string(stu.s, "李四");