前言:初识C语言只是粗略的把C的基础知识蜻蜓点水般的过一遍,后期我会分享出详细的各个知识点详解。
注意:**主函数是程序的入口。
在一个工程中,主函数有且只有一个。
C语言跨文件调用变量方法使用 extern
"hello bit\n"
这种由双引号引起来的一串字符串称为字符串字符面值,或者简称字符串。
注:字符串的结束标志是\0的转义字符,在计算字符串长度的时候\0是结束标志,不算字符串内容。
接下来通过代码演示
int main(){
char arr [] = { 'a','b','c'};
printf("%s\n", arr);
char arr2[] = { 'a','b','c','\0'};
printf("%s", arr2);
return 0;
}
由于char arr [] 后面没有加\0所以输出结果为abc后再跟一些随机值,\0的位置是不定的是。\0之前abc之后可以是任意的数字,符号,汉字。而char arr2[] 中加了\0所以只输出abc不会像上面一样输出一些奇奇怪怪的值。
故名思义就是改变其原来的意思,变成另一个意思。
假如我们要打印一个目录:c:\code\test.c\n,可能我们会天真以为它会原样输出,可是…
转义字符表
1. 代码中不需要的代码 可以直接删,亦可以注释
2. 代码中有些难懂地方,可以加注释,既方便自己看,也方便别人看自己的代码。
C语言的注释风格/…/AA
缺点:不能嵌套注释
如果你打码把键盘敲烂,那么你就月薪多万,走上人生巅峰。
如果你不打码,那么毕业即失业,就只能搬砖去了。
这就是选择!
int main()
{
int coding = 0;
printf("你会去敲代码吗?(选择1 or 0):>");
scanf("%d", &coding);
if (coding == 1)
{
prinf("坚持,走上人生巅峰r\n");
}
else
{
printf("放弃,工地搬砖!\n");
}
return 0;
}
有些事必须一直做,比如日复一日的学习,打代码。比如四季轮回。
循环语句有三类
int main()
{
int n;
int sum=0;
int i = 1;
scanf("%d", &n);
while (i <= n)
{
sum += i;
i++;
}
printf("%d\n", sum);
return 0;
}
循环次数最少0次
int main()
{
int n;
int sum=0;
int i = 1;
scanf("%d", &n);
do{
sum += i;
i++;
} while (i <= n);
printf("%d\n", sum);
return 0;
}
先循环,再判断,循环次数最少1次
int main()
{
int sum=0;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
sum += i;
}
printf("%d\n", sum);
return 0;
}
int Add(int x, int y)
{
return x+y;
}
int main()
{
int num1 = 0;
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = Add(num1, num2);
printf("sum = %d\n", sum);
return 0;
}
函数的特点就是:简化代码,提高代码复用性
数组:一组相同类型元素的集合
C语言规定:数组的每个元素都有下标,下标是从0开始的。
数组可以通过下标来访问。
int arr[10] = { 0 };
//定义一个数组里面有10个元素,下标范围是0~9。
int main() {
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
for (int i = 0; i <= 9; i++) {
printf("%d\n", arr[i]);
}
return 0;
}
算术操作符
+ - * / %
移位操作符
>> <<
位操作符
& ^ |
赋值操作符
= += -= *= /= &= ^= |= >>= <<=
单目操作符
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度(以字节为单位)
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符(解引用操作符)
(类型) 强制类型转换
int main() {
//C语言中,0表示假,非0表示真
int flag = 5;
if (!flag) {
printf("hehehehe\n");
}
return 0;
}
int main() {
int a = -10;
int b = +a;
printf("%d\n", b);
return 0;
}
++与--
int main() {
int a = 10;
/*int b = a + 1;*/
int b = a++;//前置++,先++,后使用//a=a+1;b=a;
int b = ++a;//后置+=,先使用,后++//int b=a;a=a+1;
int b = --a;*///a=a-1;b=a;
int b = a--;//b=a; a=a-1;
printf("a=%d b=%d\n", a, b);
return 0;
}
关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
逻辑操作符
&& 逻辑与
|| 逻辑或
条件操作符
exp1 ? exp2 : exp3
下标引用,函数调用和结构成员
[] () . ->
int main() {
int arr[10] = { 0 };
arr[5] = 9;//[]下标引用操作符,它的操作数:数组名,下标。
return 0;
}
int get_max(int x,int y) {
return x > y ? x : y;
}
int main() {
int m = get_max(3, 5); //函数的调用操作符,它的操作数是:函数名,3,5
printf("%d", m);
return 0;
}
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 unsigned int uint_32;
int main()
{
//观察num1和num2,这两个变量的类型是一样的
unsigned int num1 = 0;
uint_32 num2 = 0;
printf("%d\n", num1);
printf("%d", num2);
return 0;
在C语言中: static是用来修饰变量和函数的
//代码1
void text() {
int k = 0;
k++;
printf("%d\n", k);
}
int main() {
for (int i = 0; i < 10; i++) {
text();
}
return 0;
}
void text() {
static int k = 0;
k++;
printf("%d\n", k);
}
int main() {
for (int i = 0; i < 10; i++) {
text();
}
return 0;
}
结论:
static修饰局部变量改变了变量的生命周期 让静态局部变量出了作用域依然存在,到程序结束,生命周期才结束。
解释:
// static修饰的局部变量时候,局部变量就变成了静态的局部变量 // 出了局部范围,不会销毁,下一次进入函数依然存在 // 其实是因为:static修饰的局部变量是存储在静态区的 // static修饰局部变量是,实际改变的是变量的存储位置,本来一个局部变量是放在栈区的,被static // 修饰后放在静态区,从而导致,出了作用域依然存在,生命周期并没有结束
修饰全局变量-称为静态全局变量 或者修饰函数-称为静态函数
一个全局变量和函数是具有外部链接属性的,但是被static修饰后外部属性就变成了内部链接属性,只能在自己所在的源文件内部使用了。给人感觉上是作用域变小了
int main() {
int a = 10;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
//计算变量或其类型所占空间的大小
return 0;
}
int main() {
int a = 20;
register int a = 10;//建议将10放到寄存器上
return 0;
}
定义常量
#define MAX 1000
int main() {
int m = MAX;
printf("%d", m);
return 0;
}
定义宏
#define MAX(x,y)(x>y?x:y)
int main() {
int a = 90;
int b = 98;
int m = MAX(a, b);
printf("%d", m);
return 0;
}
引文:电脑有32位操作系统/操作系统64,而32位和64位代表着什么呢?待我慢慢道来。就举32位操作系统为例,32位代表电脑有32根地址线/数据线。地址线接上电线在通电的话便可以产生电信号,电信号又会转换成数字信号1/0。电脑帮我们储存的数据,图片,音乐等等。都是储存在内存当中,而每个内存都有自己的地址,也有自己的大小,一个内存单元的大小就是一个字节。32位能产生2的32次方个地址,,就是00000000000000000000000000000000到11111111111111111111111111111111,也就意味着32位的电脑的内存是4G。我们所学的指针也不过就是地址,没有我们想的那么高不可攀。
二话不说上代码
int main() {
char a = 'w';
//%p打印地址
printf("%p\n", &a);
return 0;
}
//内存单元都有编号,编号就是地址,我们把地址称为
int main() {
int a = 10;
int* pa = &a;//pa是用来存放地址的,所以我们把pa叫做指针变量
*pa = 1000;//*解引用操作符,它的意思就是通过pa中存放的地址,找到pa指向的内容。
printf("%d", a);
return 0;
}
指针大小
//指针大小
int main() {
int a = 10;
int* pa = &a;
printf("%d",sizeof(pa));
return 0;
}
结论:指针大小在32位平台是4个字节,64位的平台是8个字节。
//结构体
struct stu {
char name[20];
int age;
char sex[3];
char id[20];
};
void print(struct stu* ps, struct stu* pd) {
/*printf("%s %d %s %s\n", (*ps).name, (*ps).age, (*ps).sex, (*ps).id);*/
//->结构成员访问操作符
//J结构指针->结构体成员
printf("%s %d %s %s\n",ps->name,ps->age,ps->sex,ps->id );
printf("%s %d %s %s\n", (*pd).name, (*pd).age, (*pd).sex, (*ps).id);
}
int main() {
//结构体变量
struct stu s1 = {"叶秋涵",19,"女","202104040207"};
struct stu s2 = { "叶子秋",19,"男","202104040208" };
//.结构成员访问操作符
//结构体变量.结构体成员
//输出结构体数据
scanf("%s %d %s %s\n",s1.name,&(s1.age),s1.sex,s1.id);
/*printf("%s %d %s %s\n", s1.name, s1.age, s1.sex, s1.id);
printf("%s %d %s %s", s2.name, s2.age, s2.sex, s2.id);*/
print(&s1, &s2);
return 0;
今天的博客分享到此结束,希望对你的学习有所帮助!