1.C语言初识

王RuaRua2025-03-02 23:23

C语言初识

C语言初识

基础知识

C面向过程，C++，Java面向对象。

text.h头文件

test.c

test.cpp编译器会按C++编译

编辑、（编译、连接、运行 ctrl+F5）、调试 F5 F10

掌握了一定的语法，有时间就刷题，伴随整个学习过程。

Byte=8bit, 1024Byte=KB_MB_GB_TB_PB

hello world

c 复制代码 
#include <stdio.h>
int main()
{
	printf("hello world\n");
	returen 0;//返回整数
}

代码从main函数开始写。main函数是程序的开始，从main函数第一行执行，只能存在一个。

printf：是一个库函数，在屏幕上打印数据，使用前需要包含头文件#include <stdio.h>

""：是字符串

/n：是换行符

returen 0：返回整数

数据类型

数据类型 意义 字节
char 字符数据类型 1
short 短整型 2
int 整型 4
long 长整型 4\8
long long 整形 8
float 单精度浮点数 4
double 双精度浮点数 8
long double 扩展精度浮点数 8
c 复制代码 
#include <stdio.h>  
int main()  
{  
	printf("%d\n", sizeof(char));
	printf("%d\n", sizeof(short));
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof(long));
	printf("%d\n", sizeof(long long));
	printf("%d\n", sizeof(float));
	printf("%d\n", sizeof(double));
	printf("%d\n", sizeof(long double));
return 0;  
}

%d：以10进制的形式打印一个整数

sizeof：操作符，计算类型/变量所占内存大小

变量、常量

生活中的有些值是不变的（比如：圆周率，性别，身份证号码，血型等等）

有些值是可变的（比如：年龄，体重，薪资）。

变量命名

只能由字母（包括大写和小写）、数字和下划线（ _ ）组成。

不能以数字开头。

长度不能超过63个字符。

变量名中区分大小写的。

变量名不能使用关键字。

c 复制代码 
#include <stdio.h> 
int main() 
{
	int age=20; 
	//类型 变量名 = 初始值

	double weight = 55.5; 
	//55.5默认为double

	float weight2 = 55.5f; 
	//55.5f为float 
	//变量名不能以数字开头

	return 0; 
}

变量分类

c 复制代码 
#include <stdio.h>
int global = 2019;//全局变量
int main()
{
	int local = 2018;//局部变量
	int global = 2020;//局部变量
	printf("global = %d\n", global);//打印结果为global = 2020
	return 0;
}

局部变量 放在框外的变量

全局变量 放在框内

全局和局部冲突时，局部优先

变量的使用

C 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int num1 = 0;
	int num2 = 0;
	int sum = 0;
	printf("输入两个操作数:>");
	scanf("%d %d", &num1, &num2);
	//scanf(格式%d整型，&取地址操作符，取出num1的地址)
	sum = num1 + num2;
	printf("sum = %d\n", sum);
	return 0;
}

使用scanf报错：

错误 C4996 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

（微软编译器认为scanf函数不安全，建议使用scanf_s。但_s只有VS认识）

（1.建议使用scanf， 在第一行加：#define _CRT_SECURE_NO_WARNINGS 1）

（2.在newc++.file中加上#define _CRT_SECURE_NO_WARNINGS 1，默认添加）

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
//scanf：输入数据，从键盘读取到内存
//printf：输出数据，从内存输出到屏幕
//库函数-C语言编译器提供的函数，使用时需要包含头文件
#include <stdio.h>
int main()
{
	//int a = 0;
	//scanf("%d",&a);
	%d输入格式，&a取地址a，即数据存储地址
	//printf("%d",a);
	char ch = 0;
	scanf("%c",&ch);
	printf("%c",ch);
	return 0;
}

%c-字符

%d-整形

%s-字符串

%f-float

%lf-double

%p-地址的打印

变量的作用域

c 复制代码 
int g_val = 2024;//add.c 全局变量

extern int g_val;//需要声明外部符号才能使用全局变量
printf("%d",g_val);

作用域（scope）

  1. 局部变量：局部范围。
  2. 全局变量：整个工程。
  3. 声明外部符号才能使用全局变量：extern int g_val;
    生命周期
    变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段
    //变量创建的本质：在内存中开辟一块空间，存放数据。
    //销毁：把空间还给操作系统。
  4. 局部变量：进入作用域生命周期开始，出作用域生命周期结束。
  5. 全局变量：整个程序的生命周期

常量

c 复制代码 
#define SIZE 10//#define定义的标识符常量 
#define MAX 1000
#define CH 'W'
const int n = 3;//长变量本质还是变量

int arr[10];//数组中必须使用常量，不能使用[n]
int arr[SIZE]; //#define定义的标识符常量
  1. 字面常量。int a = 3；
  2. 常变量：具有常属性的变量。 const int n = 3;

  3. define 定义的标识符常量 # define SIZE 10

  4. 枚举常量：一一列举（性别、颜色、血型）enum SEX
c 复制代码 
enum SEX
{//列出枚举类型enum SEX可能的值,默认从0开始。
	MALE=4,
	FEMALE,
	SECRET
};
int main()
{
	printf("%d\n",MALE);
	printf("%d\n", FEMALE);
	printf("%d\n", SECRET);
	return 0;
}

字符

字符串

c 复制代码 
#include <string.h>//warning C4013: "strlen"未定义；
int main()
{
	char ch1[6] = { 'a','b','c','d','e','f' };
	char ch2[] = "abcdef";//字符串的结束标志是一个 \0的转义字符
	printf("%s\n", ch1);
	printf("%s\n", ch2);
	int len1 = strlen(ch1);//strlen:计算字符长度，\0不统计
	int len2 = strlen(ch2);
	printf("%d\n",len1);
	printf("%d\n", len2);
	//abcdef烫烫烫MF袆,since打印到\0停止
	//abcdef
	//19,since计算到\0停止
	//6
	return 0;
}

字符串：由双引号（Double Quote）引起来的一串字符称为字符串字面值（String Literal）。字符串的结束标志是一个 \0的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容。

调试：逐语句(S)-F11__逐过程(0)-F10__跳出(T)-Shift+F11

转义字符

c 复制代码 
int main()
{
	printf("(are you ok??)\n");//??)-->]，三字母词会被转为]
	printf("(are you ok\?\?)\n");//\? 在书写连续多个问号时使用，防止他们被解析成三字母词
	return 0;
}
c 复制代码 
int main()
{
	printf("c:\test\test.c\n");
	printf("c:\\test\\test.c\n");
	//c:      est     est.c,since \t 会被解析为制表符tab
	//c:\test\test.c
	//\\ 用于表示一个反斜杠，防止它被解释为一个转义序列符
	return 0;
}
转义字符 释义
\? 在书写连续多个问号时使用，防止他们被解析成三字母词
\' 用于表示字符常量'
\" 用于表示一个字符串内部的双引号
\\ 用于表示一个反斜杠，防止它被解释为一个转义序列符。
\a 警告字符，蜂鸣
\b 退格符
\f 进纸符
\n 换行
\r 回车
\t 水平制表符
\v 垂直制表符
\ddd ddd表示1~3个八进制的数字。 如： \130 表示字符X
\xdd dd表示2个十六进制数字。 如： \x30 表示字符0
c 复制代码 
int main()
{
	printf("%c\n",'\130'); 
	//\ddd ddd表示1~3个8进制的数字。 如： \130--> X的ASCII码为130
	//8进制转化为10进制，130-->88
	printf("%c\n",'\x31'); 
	//\xdd dd表示2个十六进制数字。 如： \x31 1
	//16进制转化为10进制，31-->49
	return 0;
}

选择语句

c 复制代码 
//选择语句
int main()
{
	printf("start study.\n");
	printf("do you willing study?(1 or 0)\n");
	int flag = 0;
	scanf("%d",&flag);
	if (flag == 1)
		printf("good!\n");
	else
		printf("bad!\n");
	return 0;
}

if()后无；else无；赋值使用 ==

循环语句

c 复制代码 
int main()
{
	int line = 0;
	while (line < 50)
	{
		printf("write code:%d\n",line);
		line++;
	}
	if (line == 50)
		printf("get good jio!\n");
	else
		printf("continue!!!\n");
	return 0;
}

函数；数组

c 复制代码 
#include <stdio.h>
int main()
{
	return 0;
}

函数

C 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int ADD(int x, int y)//形参
{
	int z = x + y;
	return z;
}
int main()
{
	int a = 0; int b = 0;//实参
	scanf("%d %d", &a, &b);
	int sum = ADD(a, b);
	printf("%d\n",sum);
	return 0;
}

数组

c 复制代码 
int main()
{
	int arr[10];//整形数组
	char ch[8];//字符型数组
}

数组下标

c 复制代码 
int main() 
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; 
	int i = 0; 
	while (i < 10) 
	{
		printf("%d\n", arr[i]);//数组下标从0开始arr[0]

		i++;
	}
	return 0; 
}

操作符

操作符

算术操作符

/除法

  1. 整数除法：7/2
  2. 浮点数除法：7.0/2_除数被除数，至少一个是浮点数
    %取模
  3. mod_得到的是余数
  4. 7%2_只适用于整形运算
    7.0默认为double
    7.0f 认为是float

移位操作符、位操作符

>>右移 <<左移

&与 ^异或 |或

赋值操作符

= 赋值

符合赋值：a+=5-->a=a+5

+=自增 -= *= /=

&= ^= |=

>>= <<=

单目操作符

2+3 双目：有两个操作数

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

单目：只有一个操作数

！：真假变换（0假，非0真）

c 复制代码 
int main()
{
	int a = 0;//0为假，非0为真
	if (a)//a为真，进入if
	{
		printf("ture\n");
	}
	if (!a)//a为假，进入if
	{
		printf("false\n");
	}
	printf("%d\n",!a);//会输出1
	return 0;
}

sizeof__操作数的类型长度（以字节为单位）是个操作符不是函数

c 复制代码 
int main()
{
	int a = 0;
	printf("%d", sizeof(a));
	printf("%d", sizeof a );//a的括号可以去掉，说明sizeoif不是函数
	printf("%d", sizeof(int));//但是int的不可以去掉4字节
	printf("%d", sizeof(double));//8字节
	return 0;
}

++自增

c 复制代码 
int main()
{
	int a = 1;
	int b = ++a;//前置++，先++再使用
	printf("a=%d b=%d\n", a, b);
	//a = 2 b = 2
	a = 1;
	b = a++;//后置++，先使用再++
	printf("a=%d b=%d\n", a, b);
	//a = 2 b = 1
	return 0;
}

(类型)强制类型转换

c 复制代码 
int main()
{
	int a = (int)3.14;//将3.14强制转换为整形
	printf("%d\n", a);//输出为3
	return 0;
}

关系操作符

>

>=

<

<=

!= 用于测试"不相等"

== 用于测试"相等"

逻辑操作符

&& || 逻辑与 逻辑或

&&逻辑与全真为真 ||逻辑或一真则真

c 复制代码 
int main()
{
	int a = 0;
	int b = 5;
	if (a && b)//全真才真
	{
		printf("true\n");
	}
	else
		printf("false\n");
	return 0;
}

条件操作符__三目操作符 exp__表达式

exp1? exp2 : exp3

真 执行 不执行

假 不执行 执行

c 复制代码 
int main()
{
	int a = 0; int b = 0; int m = 0;
	scanf("%d %d", &a, &b);
	m = (a > b ? a : b);//a大于b？真就输出执行a，假就执行b
	printf("%d\n", m);
	return 0;
}

逗号表达式

exp1, exp2, exp3, ...expN

从左向右依次计算

整个表达式的结果是最后一个表达式的结果

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

[] () . ->

下标引用操作符[]

c 复制代码 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//              0,1,2,3,4,5,6,7,8,9
	printf("%d\n", arr[5]);//下标5，输出为6，下标引用操作符[]，数组下标从0开始
	return 0;
}

函数调用操作符()

c 复制代码 
int z = ADD(a , b);//函数调用操作符
printf("sth");//这个也是

关键字

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

auto：自动__局部变量自动创建自动销毁，但是每个局部变量都有该性质，所以省略了auto int a;

break：循环__终止

case：switch case

char：数据类型__字符类型

const：修饰类型，常属性

continue：循环__继续

default：默认

do：循环__do while

enum：枚举类型

extern：声明外部符号的，修饰变量

goto：分支语句

register：寄存器

return：函数的返回

signed：修饰类型__有符号的

static：静止

struct：结构体

typedef：类型重命名

union：联合体类型

void：函数返回值，函数的参数，修饰指针，空的

volatile：少见

while：循环

typedef__类型重命名

c 复制代码 
typedef unsigned int u_int;
typedef unsigned long long ull;
int main()
{
	u_int num1 = 0;
	ull num2 = 2;
	return 0;
}

static__

在C语言中：

static是用来修饰变量和函数的

  1. 修饰局部变量-称为静态局部变量
  2. 修饰全局变量-称为静态全局变量
  3. 修饰函数-称为静态函数
    static 修饰局部变量的时候
    本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了
    static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束
c 复制代码 
void test()
{
	//static int a = 5;//6 7 8 9 10 11 12 13 14 15
	int a = 5;//6 6 6 6 6 6 6 6 6 6
	a++;
	printf("%d ", a);
}
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}

static修饰全局变量

全局变量具有外部链接属性，所以在其他源文件内部可以使用

static修饰全局变量，改变了全局变量的连接属性

又外部链接属性变成了内部连接属性，无法调用

无法解析的外部符号 _g_val

感觉作用域变小了，但是都在静态区

c 复制代码 
static int g_val = 2024;//add.c

extern int g_val;//声明外部符号
int main()
{
	printf("%d\n", g_val);
	return 0;
}

static修饰函数和修饰全局变量一样

函数具有外部链接属性，被static修饰变成内部链接属性

使得该函数只能在自己源文件内部使用

c 复制代码 
static int ADD(int x, int y)
{
	return(x + y);
}//add.c

extern int ADD(int x,int y);//声明外部符号
int main()
{
	int a = 0; int b = 0;
	scanf("%d %d", &a, &b);
	int s = ADD(a, b);//无法解析的外部符号 _ADD
	printf("%d\n", s);
	return 0;
}

register

c 复制代码 
int main()
{
	//register仅仅是建议作用
	//建议放在寄存器中，但不是真的放，取决于编译器
	register int num = 10;
	return 0;
}

#define 定义常量和宏

定义常量

c 复制代码 
#define M 100
int main()
{
   int arr[M] = { 0 };//int为4字节，4*100=400
   int m = M;
   printf("%d\n", sizeof(arr));//400
   printf("%d\n", M);//100
   return 0;
}

定义宏

c 复制代码 
#define ADD(x,y)(x+y)//宏定义：名字（参数）（实现体）
int main()
{
	int a = 10; int b = 20;
	int c = ADD(a, b);
	printf("%d\n", c);
	return 0;
}

结构体 struct

char

short

int

long

long long

float

double

复杂类型：学生：名字char，年龄int，性别char

c 复制代码 
struct Stu//结构体
{
	char name[20];//一个汉字2个字符
	int age;
	char sex[5];//需要5个字符
};
int main()
{
	struct Stu s = {"ruarua",20,"man"};
	printf("%s %d %s\n",s.name,s.age,s.sex);//结构体访问成员操作符s.成员
	return 0;
}

static; define; struct

static__

在C语言中：

static是用来修饰变量和函数的

  1. 修饰局部变量-称为静态局部变量
  2. 修饰全局变量-称为静态全局变量
  3. 修饰函数-称为静态函数
    static 修饰局部变量的时候
    本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了
    static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束
c 复制代码 
void test()
{
	//static int a = 5;//6 7 8 9 10 11 12 13 14 15
	int a = 5;//6 6 6 6 6 6 6 6 6 6
	a++;
	printf("%d ", a);
}
int main()
{
	int i = 0;
	while (i < 10)
	{
		test();
		i++;
	}
	return 0;
}

static修饰全局变量

全局变量具有外部链接属性，所以在其他源文件内部可以使用

static修饰全局变量，改变了全局变量的连接属性

又外部链接属性变成了内部连接属性，无法调用

无法解析的外部符号 _g_val

感觉作用域变小了，但是都在静态区

c 复制代码 
static int g_val = 2024;//add.c

extern int g_val;//声明外部符号
int main()
{
	printf("%d\n", g_val);
	return 0;
}

static修饰函数和修饰全局变量一样

函数具有外部链接属性，被static修饰变成内部链接属性

使得该函数只能在自己源文件内部使用

c 复制代码 
static int ADD(int x, int y)
{
	return(x + y);
}//add.c

extern int ADD(int x,int y);//声明外部符号
int main()
{
	int a = 0; int b = 0;
	scanf("%d %d", &a, &b);
	int s = ADD(a, b);//无法解析的外部符号 _ADD
	printf("%d\n", s);
	return 0;
}

register

c 复制代码 
int main()
{
	//register仅仅是建议作用
	//建议放在寄存器中，但不是真的放，取决于编译器
	register int num = 10;
	return 0;
}

#define 定义常量和宏

定义常量

c 复制代码 
#define M 100
int main()
{
   int arr[M] = { 0 };//int为4字节，4*100=400
   int m = M;
   printf("%d\n", sizeof(arr));//400
   printf("%d\n", M);//100
   return 0;
}

定义宏

c 复制代码 
#define ADD(x,y)(x+y)//宏定义：名字（参数）（实现体）
int main()
{
	int a = 10; int b = 20;
	int c = ADD(a, b);
	printf("%d\n", c);
	return 0;
}

结构体 struct

char

short

int

long

long long

float

double

复杂类型：学生：名字char，年龄int，性别char

c 复制代码 
struct Stu//结构体
{
	char name[20];//一个汉字2个字符
	int age;
	char sex[5];//需要5个字符
};
int main()
{
	struct Stu s = {"ruarua",20,"man"};
	printf("%s %d %s\n",s.name,s.age,s.sex);//结构体访问成员操作符s.成员
	return 0;
}

指针

内存

指针是用来访问内存的，就是内存单元的地址。

每个内存单元的大小是1个字节Byte 。

32位的计算机有32根地址线，电信号，可以管理2^32个字节的空间=4GB内存

![[Pasted image 20250101231015.png]]

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

取变量地址

0x开头是16进制

c 复制代码 
int main()
{
	int num = 10;//申请4字节空间
	&num;//取num地址，num4字节，每个字节都有地址，取出的是第一个字节的地址
	printf("%p\n", &num);//%p是以地址的形式打印__0x004ffbe8
	return 0;
}//一个整数4字节，32bit，16进制，4个二进制位转化一个16进制位

![[Pasted image 20250101232539.png]]

指针变量 int* p;存放指针的变量

*：p是指针变量

int：p指向的是int类型的变量

c 复制代码 
int main()
{
	int a = 10;
	int* p;//p为一个整形指针变量
	*p = 30;//*p,解引用p，*p就是a
	printf("%d\n", a);//a=30
	return 0;
}

指针变量大小

32位机器：地址是32个地址位，4字节；

64位机器：地址64位，8字节。

c 复制代码 
int main()
{
	int a = 10;
	int* p = &a;
	printf("%zd\n", sizeof(p));//x86是4字节，x64是8字节
	printf("%zd\n", sizeof(int*));//x86是4字节，x64是8字节
	return 0;
}
相关推荐
千里码aicood10 分钟前
[含文档+PPT+源码等]精品基于Python实现的vue3+Django计算机课程资源平台
开发语言·python·django
邴越12 分钟前
LeetCode 2 - 两数相加
算法·leetcode·职场和发展
Y雨何时停T26 分钟前
Java 容器之 List
java·开发语言·list
大丈夫在世当日食一鲲30 分钟前
Java的流表达式使用
java·开发语言·windows
西北大程序猿31 分钟前
前缀和算法 算法4
算法
多多*36 分钟前
题解 | 牛客周赛83 Java ABCDEF
java·开发语言·macos·objective-c·cocoa·工厂方法模式
wusixuan13100438 分钟前
c++ 文件及基本读写总结
开发语言·c++
axxy200040 分钟前
C++ Primer Plus第九章课后习题总结
开发语言·c++·算法
m0_zj40 分钟前
30.[前端开发-JavaScript基础]Day07-数组Array-高阶函数-日期Date-DOM
开发语言·前端·javascript
熊出没1 小时前
解锁责任链模式：Java 实战与应用探秘
java·开发语言·责任链模式
热门推荐
01DeepSeek各版本说明与优缺点分析02本地部署DeepSeek教程（Mac版本）03如何在WPS和Word/Excel中直接使用DeepSeek功能04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06DeepSeek本地部署详细指南07Anaconda +Jupyter Notebook安装（2025最新版）08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09DeepSeek r1本地安装全指南10保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型