初阶第一节-初识C语言

m0_68124969

已于 2023-08-19 09:53:00 修改

阅读量66

点赞数

文章标签： c语言

于 2023-08-10 09:46:00 首次发布

本文链接：https://blog.csdn.net/m0_68124969/article/details/132202364

版权

1.数据类型

1.1数据类型的分类

char //字符数据类型

short //短整型

int //整形

long //长整型

long long //更长的整形

float //单精度浮点数

double //双精度浮点数

字符类型：
   char ch = 'a';
整型：
   int age = 20;
短整型：
   short num = 10;

长/更长整型：
   //long
   //long long

单精度浮点型：
   float weight = 55.5;

双精度浮点型：
   double d = 0.0;

printf("%d\n", sizeof(char));//1
printf("%d\n", sizeof(short));//2
printf("%d\n", sizeof(int));//4
printf("%d\n", sizeof(long));//4/8
printf("%d\n", sizeof(long long));//8
printf("%d\n", sizeof(float));//4
printf("%d\n", sizeof(double));//8

C语言规定：sizeof(long)>= sizeof(int)

%zu

sizeof()

用sizeof来求字符的大小

1.2计算机中的单位

bit	8	byte
byte	1024	kb
kb	1024	mb
mb	1024	gb
gb	1024	tb
tb	1024	pb

2.变量，常量

2.1变量和常量

变量和常量概念：生活中的有些值是不变的(比如：圆周率，性别，身份证号码，血型等等)；有些值是可变的(比如：年龄，体重，薪资)。不变的值，C语言中用常量的概念来表示，变得值C语言中用变量来表示。

//变量分为：
//局部变量 - {}内部定义的变量
//全局变量 - {}外部定义的变量
#include<stdio.h>
int b = 20;//全局变量
int main()
{
	//创建的一个变量的方法：
	//类型    变量的名字 = 0;//推荐
	//类型  变量的名字;//不推荐
	short age = 20;//年龄
	int high = 180;//身高
	double weight = 75.3;//体重
    float score = 80.5f;//不加f的话，编译器会默认80.5为double类型

	int a = 10;//局部变量
	return 0;
}

#include<stdio.h>
int a = 100;//全局变量
int main()
{
	//局部变量 - {}内部定义的
	//当局部变量和全局变量名字冲突的情况下，局部优先
	//不建议：把全局变量和局部变量的名字写成一样的
	int a = 10;//局部变量
	printf("%d\n", a);//10
	return 0;
}

2.2变量的使用

//写一个代码求2个整数的和
//scanf函数是输入函数
//printf函数是输出函数
#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;
}

2.3变量的作用域和生命周期

2.3.1作用域

作用域(scope)是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的而限定这个名字的可用性的代码范围就是这个名字的作用域。 1. 局部变量的作用域是变量所在的局部范围。 2. 全局变量的作用域是整个工程。

// 作用域
//局部变量的作用域：就是变量所在的局部范围
//全局变量的作用域：整个工程

//局部变量
#include<stdio.h>
int main()
{
	{
		int a = 10;
		printf("a = %d\n", a);//10
	}
	printf("a = %d\n", a);//err
	return 0;
}

int main()
{

	int a = 10;
	{
		printf("a = %d\n", a);//10
	}
	printf("a = %d\n", a);//10
	return 0;
}

//全局变量
#include<stdio.h>
int g_val = 2021;//全局变量
int main()
{
	printf("1:%d\n", g_val);//1:2021
	{
		printf("2:%d\n", g_val);2:2021
	}
	printf("3:%d\n", g_val);//3:2021
	return 0;
}

2.3.2生命周期

生命周期
变量的生命周期：变量的创建和销毁之间的时间段
局部变量的生命周期：进入局部范围生命开始，出局部范围生命结束
全局变量的生命周期：程序的生命周期

2.4常量

C语言中的常量和变量的定义的形式有所差异。 C语言中的常量分为以下以下几种：字面常量；const 修饰的常变量；#define 定义的标识符常量；枚举常量。

#include<stdio.h>
#define MAX 10000   
int main()
{
	//1. 字面常量
	//3.14;
	//10;
	//'a';
	//"abcdef";

	//2. const修饰的常变量
	const int num = 10;//在C语言中，const修饰的num就是常变量 - 本质是变量，具有常属性(不能被改变的属性)
	num = 20;//err
	printf("num = %d\n", num);//无const为20，有const为10

	//解释常变量:
	int arr[10] = { 0 };//10个元素
	const int n = 10;
	int arr[n] = { 0 };//err - arr[]里面要放的是常量，n是变量

    //3. #define 定义的标识符常量
	//MAX = 2000//err
	int n = MAX;
	printf("%d\n", n);//1000
	return 0;
}

//4. 枚举常量
#include<stdio.h>
enum Sex//性别
{
	//这种枚举类型的变量的未来可能取值
	//枚举常量
	MALE = 3,//赋初值，不赋初值的话默认为0
	FEMALE,//4
	SECRET//5
};
int main()
{
	//可以一一列举的常量   
	MALE = 3;//err
	printf("%d\n", MALE);//3
	printf("%d\n", FEMALE);//4
	printf("%d\n", SECRET);//5
	return 0;
}

3.字符串+转义字符+注释

3.1字符串

"hello bit.\n" 这种由双引号(Double Quote)引起来的一串字符称为字符串字面值(String Literal)，或者简称字符串。注：字符串的结束标志是一个 \0 的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容。

#include<stdio.h>
#include <string.h>
int main()
{
	//100 - int 
	// char字符类型，'a'
	// char ch = 'a'
	// 字符串，"abcdef"
	// C语言中没有字符串类型
	//字符数组 - 数组是一组形同类型的元素
	//字符串在结尾的位置隐藏了一个\0的字符
	//\0是字符串的结束标志

	char arr1[] = "abc";//abc\0
	char arr2[] = { 'a', 'b', 'c' };//abc
	char ch[5] = { 'a', 'b', 'c' };//不完全初始化，剩余的默认为0

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

	//求一下字符串的长度
	printf("%d\n", strlen(arr1));//3
	printf("%d\n", strlen(arr2));//随机值
	int len = strlen("abc");//string length
	printf("%d\n", len);//3

	//求一下字符串的大小(单位：字节)
	printf("%d\n", sizeof(arr1));//4
	printf("%d\n", sizeof(arr2));//3
	printf("%d\n", sizeof(ch));//5
	return 0;
}

3.2转义字符

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

#include<stdio.h>
#include<string.h>
int main()
{
	//\?的使用
	printf("(are you ok??)");//??) -- ] - 三字母词
	//有些编译器会打出(are you ok]
	printf("(are you ok\?\?)");//(are you ok??)

	printf("%c\n", '\'');//'
	printf("%s\n", "abc");//abc
	printf("%s\n", "a");//a
	printf("%s\n", "\"");//"
	printf("%s\n", "'");//'
	printf("c:\\test\\test.c");//c:\\test\\test.c

	printf("%c\n", '\130');//X - 8进制的130是十进制88，X -- ASCII码值是88
	printf("%c\n", '\101');//A - 8进制的101是十进制65，A -- ASCII码值是65
	printf("%c\n", '\x63');//c - 16进制的63是十进制99，c -- ASCII码值是99 

	printf("%d\n", strlen("abc"));//3
	printf("%d\n", strlen("c:\test\328\test.c"));//14 - 8进制的取值范围是0~7
	return 0;
}

3.3注释

注释有两种风格： 1.C语言风格的注释 /*xxxxxx*/ ，缺陷：不能嵌套注释(即出现/*后遇到*/就完成了注释。2.C++风格的注释 //xxxxxxxx ，可以注释一行也可以注释多行。

4.选择语句与循环语句

4.1选择语句

#include<stdio.h>
int main()
{
	int input = 0;//输入的值
	printf("加入比特:>\n");
	printf("那要好好学习吗(1/0)?>:");
	scanf("%d", &input);
	if (input == 1)
	{
		printf("好offer\n");
	}
	else
	{
		printf("卖红薯\n");
	}
	return 0;
}

4.2循环语句

#include<stdio.h>
//比特 - 30000代码 - 找一个不错的工作
int main()
{
	int line = 0;
	//循环
	while (line < 30000)
	{
		printf("写代码:%d\n", line);
		line++;
	}
	if (line == 30000)
	{
		printf("好offer\n");
	}
	return 0;
}

5.函数与数组

5.1函数

#include<stdio.h>
int Add(int x, int y) //int是返回类型；Add是函数名；int x和int y是函数参数
{
	int z = 0;
	z = x + y;
	return z;//return x+y;
}
int main()
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d%d", &num1, &num2);
	int sum = Add(num1, num2);//函数的方式解决
	printf("%d\n", sum);
	return 0;
}

5.2数组

5.21数组的定义和下标

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

          下标：0,1,2,3,4,5,6,7,8,9

char ch[5] = {0};
double d[30] = {0};

5.22数组的使用

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	while (i < 10)
	{
		printf("%d ", arr[i]);//1 2 3 4 5 6 7 8 9 10
		i++;
	}
	return 0;
}

6.操作符

6.1操作符的分类

//算数操作符/和%
int a1 = 9 / 2;
float a2 = 9 / 2.0;//等价于9.0 / 2.0和9.0 / 2
int a3 = 9 % 2;//% - 取模(余)
//取模操作符的两个操作符只能是整数
printf("%d\n", a1);//4
printf("%f\n", a2);//4.500000
printf("%.1f\n", a2);//4.5
printf("%d\n", a3);//1


//赋值操作符   
int a = 2;

a = a + 5;//7
a += 5;

a = a - 3;//-1
a -= 3;

a = a % 3;//2
a %= 3;
    ......

//单目操作符(只有一个操作数的操作符) !
#include<stdio.h>
int main()
{
    //0 表示假，非0就是真
    int a = 0;
    printf("%d\n", !a);//1

    if (a)
    {
        //如果a为真，做事
    }
    if (!a)
    {
        //如果a为假，做事
    }
    return 0;

}



//正负值
int a = -5;
int a = -a;//5
int a = +a;//-5


//sizeof
//是一个操作符
//不是函数
//计算类型或者变量的大小的

int a = 10;
printf("%d\n", sizeof(int));//4 
printf("%d\n", sizeof(a));//4

int arr1[10] = { 0 };
printf("%d\n", sizeof(arr));//10*4=40 - 计算的是数组的总大小，单位是字节
printf("%d\n", sizeof(arr[0]));//4

printf("%d\n", sizeof arr[0]);//4
int sz = sizeof(arr) / sizeof(arr[0]);
printf("%d\n", sz);//10 - 数组的元素个数

char arr2[] = "welcome to bit!!!!";
int sz = sizeof(arr2) / sizeof(arr2[0]);
printf("%d\n", sz);//19 - 计算的时候包含了\0

char arr3[] = { 'a', 'b', 'c' };//abc
printf("%d\n", sizeof(arr3));//3

char ch[5] = { 'a', 'b', 'c' };//不完全初始化，剩余的默认为0
printf("%d\n", sizeof(ch));//5


//前置、后置++
int a = 10;
int b = a++;//后置++，先使用，再++
//b=a；a=a+1；

printf("%d\n", b);//10
printf("%d\n", a);//11

int b = ++a;//前置++ - 先++，后使用
//b=a+1；a=a+1；

printf("%d\n", b);//11
printf("%d\n", a);//11


//前置、后置--
int a = 10;
int b = a--;//后置--，先使用，再--
//b=a；a=a-1；

printf("%d\n", b);//10
printf("%d\n", a);//9


int b = --a;//前置-- - 先--，后使用
//b=a-1；a=a-1；

printf("%d\n", b);//9
printf("%d\n", a);//9



//强制类型转换
int a = 3.14;
int a = (int)3.14;
printf("%d\n", a);//3
//3.14 字面浮点数，编译器默认理解为double类型

//==
#include<stdio.h>
int main()
{
    int a = 10;
    if(a = 3)//为真，打印hehe；若(a == 3)，则不打印hehe
    {
        printf("hehe");
    }
    return 0;
}

// &&和 ||
#include<stdio.h>
int main()
{
    int a = 2;
    int b = 3;
    if (a && b)
    {
        printf("hehe");//a和b都为真时才会打印
    }
    int a = 2;
    int b = 3;
    if (a || b)
    {
        printf("hehe");//a和b至少有一个为真时才会打印
    }
    return 0;
}

//exp1 ? exp2 : exp3
//若exp1为真，则输出 exp2
//若exp1为假，则输出 exp3
#include<stdio.h>
int main()
{
    int a = 0;
    int b = 3;
    int max = 0;

    //if (a > b)
    //    max = a;
    //else
    //    max = b;

    max = a > b ? a : b;
    printf("%d\n", max);
    return 0;
}

#include<stdio.h>
int main()
{
    int a = 0;
    int b = 3;
    int c = 5;
            //a=5       c=1        b=3
    int d = (a = b + 2, c = a - 4, b = c + 2);
    //逗号表达式，是从左向右依次计算的
    //整个表达式的结果是最后一个表达式的结果

    printf("%d\n", d);//3
    return 0;
}

//下标引用操作符[]
#include<stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int n = 3;
    arr[n] = 20;//[]就是下标引用操作符，arr和3就是[]的操作数
    printf("%d\n", arr[n]);
    return 0;
}


//函数调用操作符()
#include<stdio.h>
int Add(int x, int y)
{
    return x + y;
}
int main()
{
    int sum = Add(2, 3);//()就是函数调用操作符，Add，2，3都是()的操作数
    return 0;
}

7.常见关键字

7.1关键字typedef

//typedef 顾名思义是类型定义，这里应该理解为类型重命名
#include<stdio.h>
typedef struct Node //将struct Node重命名为Node, 所以Node也是一个类型名
{
    int data;
    struct Node* next;
}Node;



typedef unsigned int u_int;//将unsigned int重命名为uint_32, 所以uint_32也是一个类型名
int main()
{
    unsigned int num = 100;
    u_int num2 = 100;

    struct Node n1;
    Node n2;
    return 0;
}

7.2关键字static

在C语言中： static是用来修饰变量和函数的 1.修饰局部变量-称为静态局部变量；2.修饰全局变量-称为静态全局变量；3.修饰函数-称为静态函数

//修饰局部变量
//static修饰局部变量的时候，局部变量出了作用域，不销毁的。本质上，static修饰局部变量的时候，改变了变量的存储位置(由栈区变为静态区)。影响了变量的生命周期，生命周期变长，和程序的生命周期一样。

#include<stdio.h>
void test()
{
    static int a = 1;
    a++;
    printf("%d ", a);//不加static 2 2 2 2 2 2 2 2 2 2
                     //加static   2 3 4 5 6 7 8 9 10 11
}
int main()
{
    int i = 0;
    while (i<10)
    {
        test();
        i++;
    }
    return 0;
}

8.#define定义常量和宏

//define 是一个预处理指令
//1.define定义符号

#include<stdio.h>
#define MAX 1000
int main()
{
    printf("%d\n", MAX);//1000
    int n = MAX;
    printf("%d\n", n);//1000
    int arr[MAX] = { 0 };
    return 0;
}



//2. define 定义宏
#define ADD(X,Y) ((X)+(Y))
//ADD是宏名；X和Y是宏的参数，参数是无类型的；((X)+(Y))是宏体

#include<stdio.h>
int main()
{
    printf("%d\n", 4*ADD(2, 3));//20
    return 0;
}

9.指针

9.1指针的内存

#include<stdio.h>
int main()
{
    int a = 10;//a在内存中要分配空间的 - 4个字节
    printf("%p\n", &a);//%p 专门用来打印地址的
    //&a中&是取地址操作符，&a就是取出a的地址，比如0x0012ff40

    int * pa = &a;//pa是用来存放地址的，在C语言中pa叫是指针变量，pa=&a
                  //* 说明 pa是指针变量；int 说明pa执行的对象是int类型的

    *pa = 20;//解引用操作符，意思就是通过pa中存放的地址，
             //找到pa所指向的对象，*pa就是pa指向的对象，*pa=a

    char ch = 'w';
    char * pc = &ch;
    return 0;
}

9.2指针内存的大小

//不管是什么类型的指针，都是在创建指针变量
//指针变量是用来存放地址的
//指针变量的大小取决于一个地址存放的时候需要多大的空间
//32位机器上的地址：32bit位 - 4byte，所以指针变量的大小是4个字节
//64位机器上的地址：64bit位 - 8byte，所以指针变量的大小是8个字节

#include<stdio.h>
int main()
{
    printf("%zu\n", sizeof(char*));//4
    printf("%zu\n", sizeof(short*));//4
    printf("%zu\n", sizeof(int*));//4
    printf("%zu\n", sizeof(long*));//4
    printf("%zu\n", sizeof(long long*));//4
    printf("%zu\n", sizeof(float*));//4
    printf("%zu\n", sizeof(double*));//4
    return 0;
}

10.结构体

#include<stdio.h>
//学生
struct Stu
{
    //成员
    char name[20];
    int age;
    char sex[10];
    char tele[12];
};
void print(struct Stu* ps)
{
    printf("%s %d %s %s\n", (*ps).name, (*ps).age, (*ps).sex, (*ps).tele);
    //->
    //结构体指针变量->成员名
    printf("%s %d %s %s\n", ps->name, ps->age, ps->sex, ps->tele);
}
int main()
{
    struct Stu s = { "zhangsan", 20, "nan", "15926589087" };
    //结构体对象.成员名 
    printf("%s %d %s %s\n", s.name, s.age, s.sex, s.tele);
    print(&s);
    return 0;
}