鹏哥C语言初识课程总结

常见单位和数据类型的范围

bit byte kb mb gb tb pb

#include<stdio.h>
int main(){
	printf("%d\n",sizeof(char)); //1  2^8 == 1024
	printf("%d\n",sizeof(int));  //4  2^32 == 4294967296 
//-2,147,483,648 到 2,147,483,647。10位数
	printf("%d\n",sizeof(float)); //4
	printf("%d\n",sizeof(double)); //8
	printf("%d\n",sizeof(long));  //4
	printf("%d\n",sizeof(short));  //2
	printf("%d\n",sizeof(long long));  //8
	return 0;
}

全局变量和局部变量

#include<stdio.h>
int a = 100;//全局变量
int main(){
    int a = 10;//函数里的局部变量，可以和全局变量名字相同，但是局部优先
	printf("%d",a);//10
	return 0;
}

变量的作用域

局部变量的作用域

局部范围【函数里】

#include<stdio.h>
int main(){

{
	int a = 100;
	printf("%d",a);
}
printf("%d",a);
	return 0;
}

全局函数的作用域

作用域整个工程

#include<stdio.h>
int a = 100;//全局变量
int main(){

{

	printf("%d ",a);
}
printf("%d",a);
	return 0;
}

变量的生命周期 ~= 变量的作用域

局部变量的生命周期

进入作用域开始，离开作用域结束

全局变量的生命周期

整个工程

常量

字面常量【只有这个常量可以修改】

#include<stdio.h>
int main(){
int a = 20;
 a = 50;
printf("%d",a);//50
	return 0;
}

可以修改a的值

const修饰的常变量

#include<stdio.h>
int main(){

const int a = 20;
 a = 50;//报错，常变量 不可更改
printf("%d",a);
	return 0;
}

define定义的标识符常量

#include<stdio.h>
#define max 100
#define str "qwert"
//没有数据类型
int main(){

max = 123; //error 不可修改
// a = 50;
printf("%d",max);
printf("%s",str);
	return 0;
}

枚举常量

#include<stdio.h>
//#define max 100
//#define str "qwert"
enum Color{
	RED,//枚举常量
	GREEN,//枚举常量
	BLUE,//枚举常量
};
int main(){
enum Color c = BLUE;//2
enum Color a = RED;//0
//printf("%s",str); error，其实枚举常量是一个数字，有点像是数组
printf("%d",c);//2
	return 0;
}

字符串

C语言里面没有字符串类型
结尾默认有\0

#include<stdio.h>
#include<string.h>
int main(){
char arr1[] = "abcd";
char arr2[] = {'a','b','c','d'};
char arr3[] = {'a','b','c','d','\0'};
printf("%s ",arr1);
printf("%s ",arr2);//随机值，没有\0结束
printf("%s ",arr3);//与arr1等价
printf("%d\n",strlen(arr1));//4    \0不算   strlen 使用需要string.h 
printf("%d\n",strlen(arr2));//随机值
printf("%d\n",strlen(arr3));//4    \0不算
	return 0;
}

函数

#include <stdio.h>
int ADD(int a, int b){//ab是形参
	int z = 0;
	z = a + b;
	return z;
//也可以直接 return a + b;
}
int main(){
	int num1 = 0;
	int num2 = 0;
	scanf("%d %d",&num1,&num2);//num1,num2是实参
	int sum = ADD(num1,num2);
	printf("%d",sum);
	return 0;
}

数组

一个重要思想：通过下标访问数组里的元素，用循环产生下标

操作符

单目操作符【对一个变量进行操作】

! - + & sizeof ~ -- ++ * (类型)

！逻辑非

#include<stdio.h>
int main(){
	int a = 22;
	int b = 0;
	printf("%d ",!a);//0
	printf("%d",!b);//1
	
	return 0;
}

-负值

#include<stdio.h>
int main(){
	int a = 22;
	printf("%d ",-a);//-22
	return 0;
}

+没有什么用，1==+1 -1 == +（-1）
sizeof
单位byte

#include<stdio.h>
int main(){
	int arr[10] = {0};
	printf("%d ",sizeof(arr));//40 计算整个数组大小
	printf("%d ",sizeof(arr[0]));//4 计算数组第一个元素占的字节数
	printf("%d ",sizeof(arr) / sizeof(arr[0]));//计算数组元素有多少个
	return 0;
}

++ --
区别i++ 与 ++i
前者先赋值[原来的值赋给别人]，再自增【自己最后在自增改变自己】
后者先自增，再复制

#include<stdio.h>
int main(){
	int a = 10;
	int b = a++;
// b = 10 a = 11
	int c = ++a;
// a = 12 c = 12
	printf("%d %d",b,c);//10 12
	return 0;
}

#include<stdio.h>
int main(){
	int a = 10;
	int b = a++;
// b = 10 a = 11
	int c = b++;
// c = 10 b = 11
	printf("%d %d %d\n",a,b,c)// 11 11 10
	return 0;
}

#include<stdio.h>
int main(){
	int a = 10;
	int b = ++a;
// a = 11 b = 11
	int c = ++b;
// b = 12 c = 12
	int num1 = 9;
	int num2 = --num1;
// num1 = 8 num2 = 8
	int num3 = --num2;
// num2 = 7 num3 = 7
	int num4 = --num3;
// num3 = 6 num 4 = 6
	printf("%d %d %d\n",a,b,c);//11 12 12
	printf("%d %d %d %d\n",num1,num2,num3,num4);//8 7 6 6 
	return 0;
}

(类型)
强制类型转化

#include<stdio.h>
int main(){
	int a = 21;
	int b = 4;
	printf("%f ",(double)a/b);//5.25
	return 0;
}

逗号运算符

都计算，但是只打印最远的那个

#include<stdio.h>
int main(){
int a = 4;
int b = 12;
int c = 6;
int tmp = (a++,b/a,c--);
//都运行了，只是只打印了c--
// a=5 
int res = (c=b/a,a=b+c,c-a);
// c = 2 ,a = 14 , c-a==-12
printf("%d %d",res,tmp);//-12  6
	return 0;
}

下标引用操作符[]

#include<stdio.h>
int main(){
int arr[10] = {0,1,2,1,3,4,5,6,6,8};//声明数组，arr[常量&null]
int n = 4;//调用数组里的元素，可以写成a[变量]
printf("%d",arr[n]);//3
	return 0;
}

函数调用操作符()

#include <stdio.h>
int ADD(int a, int b){//ab是形参
	return a + b;
//也可以直接 return a + b;
}
int main(){
	int num1 = 0;
	int num2 = 0;
	scanf("%d %d",&num1,&num2);//num1,num2是实参
	int sum = ADD(num1,num2);//ADD(),调用函数，()就是函数调用操作符
	printf("%d",sum);
	return 0;
}

条件操作符【三目操作符】

#include<stdio.h>
int main(){
int a = 100;
int b = 20;
int r = a > b? a : b;//第一个是条件，满足,r = a,反之，r = b
printf("%d",r);
	return 0;
}

指针

内存

内存会分成一个个的内存单元（一个内存单元大小1byte），每个内存单元都有自己的编号【地址，指针】
32位机器上，地址是三十二位，4byte
64……，8byte
之前声明数据类型很浪费

内存地址是2进制
太长了，用16进制打印

#include<stdio.h>
int main(){
	int a = 10;
//	&a;
printf("%p",&a);//打印地址用%p
	return 0;
}

指针变量

存放地址的变量

#include<stdio.h>
int main(){
	int a = 10;
//	&a;

int* p = &a;//p就是指针变量
printf("%p",p);
printf("%p",&a);//二者等价
	return 0;
}

解引用操作符*与取地址操作符&【一去一来，呼应】

通过*与&修改变量数值，但是地址不变

#include<stdio.h>
int main(){
	int a = 10;
    int* p = &a;//p就是指针变量
    *p = 20;
printf("%d",a);//20
	return 0;
}

指针变量大小

放地址的，只和机器位数有关

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

结构体

.操作符

结构体对象.成员名

#include<stdio.h>
struct stu//一个类型
{
	char name[20];
	int age;
	char sex[10];
	char tele[12];
};//就像是盖房子的图纸
int main(){
	struct stu s= {"zhangsan", 20, "man", 123457756};
	printf("%s %d %s %d",s.name ,s.age ,s.sex ,s.tele);
	
	
	
	return 0;
}

->箭头操作符

结构体指针变量 -> 成员名

#include<stdio.h>
struct stu//一个类型
{
	char name[20];
	int age;
	char sex[10];
	char tele[12];
};//就像是盖房子的图纸
void functionPrint(struct stu* ps){
	printf("%s %d %s %d\n",(*ps).name ,(*ps).age ,(*ps).sex ,(*ps).tele);//啰嗦，与下面等价 
	printf("%s %d %s %d",ps->name ,ps->age ,ps->sex ,ps->tele);//箭头操作符
}
int main(){
	struct stu s= {"zhangsan", 20, "man", 123457756};
	functionPrint(&s);
	
	
	return 0;
}

posted @ 2024-10-31 18:12 GJ504b 阅读(9) 评论(0) 编辑收藏举报

刷新页面返回顶部

GJ504b