旅游景点网站设计,一件代发海外电商平台,普通个人简历电子版免费,福田建网站费用1, #include
相当于java的导包操作 例如#xff1a;#include stdio.h 代表寻找系统的资源
“” 代表寻找我们自己写的资源
.h .hpp(声明文件 头文件)
.c .cpp #xff08;实现文件#xff09;
2#xff0c;代码结构
int main() { // 函数的主入…1, #include
相当于java的导包操作 例如#include stdio.h 代表寻找系统的资源
“” 代表寻找我们自己写的资源
.h .hpp(声明文件 头文件)
.c .cpp 实现文件
2代码结构
int main() { // 函数的主入口printf(哈喽!);//打印getchar(); // 阻塞程序return 0;
}
3基本数据类型 int i 100;double d 200;float f 200;long l 100;short s 100;char c d;
上面这些基本数据类型与java一致
需要注意的是 字符串类型 java中是String 而C语言中是 char * str 我是字符串;
sizeof获取字节数 下面是每个基本类型所占用的字节数 可以通过此api获取
sizeof(int)//int 占几个字节 4
sizeof(double)//double 占几个字节 8
sizeof(char)//char 占几个字节 1
sizeof(long)//long占几个字节 4
sizeof(short)//short占几个字节 2
sizeof(float)//float占几个字节 4bit——计算机的最小单位byte——1byte 8bit byte就是字节kb——1kb 1024bytemb——1mb 1024kbgb——1gb 1024mbtb——1tb 1024gbpb——1pb 1024tb4打印
打印需要注意的是不和java一样随便打印的需要占位符 printf(i的值是%d\n, i); // d 整形printf(d的值是:%lf\n, d); // lf long floatprintf(f的值是:%f\n, f); // f floatprintf(l的值是:%d\n, l); // d 整形printf(s的值是:%d\n, s); // s shortprintf(c的值是:%c\n, c); // c charprintf(字符串:%s\n, str); // s String
5指针地址
在java中万物皆对象。
在Linux中万物皆文件
在C 语言中万物皆指针
指针其实可以理解为地址 代表取出地址 例如
int number 10;
printf(此number变量的地址是:%p\n, number); // 地址 00B3FE90
* 代表取出地址所对应的值 例如
int number 100;
printf(number的值是:%d\n, *(number));//100 number代表number所对应的地址 *(number)代表取number地址所对应的值 所以输出100
int * 代表int类型的指针 说明定义的是一个指针变量就是一个变量而已只不过是指针的变量而已
例如
int a 100;
int * b a;
printf(a的值是:%d\n, *b);输出100 因为b是a的指针也就是a地址
*b代表取地址所对应的值也就是取a的地址所对应的值100
只要记住一句话内存地址就是指针指针就是内存地址
下面看一个错误的用法
int i 100;
int * p i;这种写法是错误的因为p只能接收指针给它传一个100显然是不行的
正确的写法应该是
int i 100;
int * p i;
指针变量 只能接收指针
如何通过指针修改变量值呢举个例子
int i 100;
int * p i;
i 200;
printf(*p的值是:%d\n, *p);输出200因为i变为了200p指向i*p取得是i的值*p 300;printf(i的值是:%d\n, i);输出300因为*p代表i的地址所对应的值修改成300
6函数
C语言不允许函数重载Java可以C可以
函数需要先声明再实现。 函数不能写在main函数的下面会报错
下面来看一个简单的函数例子
#include stdio.h //引入标准库void change(int * i); // 先声明 参数为指针变量int main() {int i 100;change(i);//传入指针printf(%d\n, i);//输出666return 0;//main函数返回值 也可以写为NULL
}// 再实现
// 使用指针 来修改
void change(int * i) {*i 666;
}
由于C语言不支持函数重载所以声明的函数不需要写参数
例如
void change();//不需要填写参数int main() {int a 100;int b 200;change(a, b);printf(交换完成后的效果%d,%d\n, a, b);//200 100}// 只接收指针(内存地址)
void change(int * a, int * b) {int temp *a;*a *b;*b temp;
}
7多级指针
直接看例子
int num 20;int * num_p num; // 取出num的内存地址给 num_p一级指针int ** num_p_p num_p; // 取出num_p的内存地址给 num_p_p二级指针int *** num_p_p_p num_p_p;//取出num_p_p的内存地址给 num_p_p_p 三级指针printf(获取最终的值%d\n, **num_p_p);//输出20printf(获取最终的值%d\n, *** num_ppp);//输出20是几级指针取值时前面就加几个*
8数组与数组指针 定义数组int [] arr {1,2,3,4}; 错误的写法int arr[] {1,2,3,4}; 正确写法
遍历数组
int i 0;
for (i 0; i 4; i) {printf(%d\n, arr[i]); // 取值
}
数组的内存地址 等于第一个元素的内存地址不是其他元素的地址
上面数组的内存地址可以写为arr arr arr[0]
既然数组就是一个内存地址那么
int * arr_p arr;
数组可以用地址变量赋值
操作数组就是对数组的指针进行操作。
int arr[] {1,2,3,4};将数组地址赋值给指针变量arr_p 此时指针默认指向第一个元素
int * arr_p arr; printf(%d\n, *arr_p); //输出1 因为此时指针指向第一个元素的内存地址arr_p ; // 指针挪动 此时指向元素二的内存地址了printf(%d\n, *arr_p); // 输出2 因为此时指针指向第二个元素的内存地址arr_p 2;printf(%d\n, *arr_p); // 输出4 因为此时指针指向第四个元素的内存地址数组是连续的内存空间数组每次挪动4个字节
通过循环给数组赋值
定义数组
int arr[4];赋值给指针变量arrP
int * arrP arr;循环赋值操i作
int i 0;
for (i 0; i 4; i) {// 1.拿到 元素一 元素二 元素三 元素四 的内存地址 (arrP i)// 2.取出 元素一 元素二 元素三 元素四 的内存地址 所对应的值 * (arrP i)* (arrP i) (i 10001);
}
9,函数指针
void(*methid)(int,int) 函数指针
void 返回值
(*methid) 函数名
int,int参数 可以随便写 这里只是举个例子
下面来看具体用法:
void add(int num1, int num2); // 先声明void opreate(void(*method)(int,int), int num1, int num2) {method(num1, num2);
}int main() { opreate(add, 10, 10);printf(main函数的 add指针是多少%p\n, add);// add和add是一样的值吗printf(%p, %p\n, add, add); // 一样的return 0;
}// 再实现 使用
void add(int num1, int num2) {printf(num1 num2 %d\n, (num1 num2));
}
10,C语言中的布尔类型
C语言和Java的不同就是C语言没有true和false 只有0和非0
只要记住一句话即可非0即true 0就是false
11静态开辟
在函数局部内创建的数据在执行函数的时候会进栈操作函数执行完毕会执行弹栈。因此会释放栈内的成员栈内的数据也称之为栈内成员这种方式开辟的内存称为静态开辟执行完会弹栈。不会占用内存空间。
静态开辟即在栈区开辟内存
int a;
int arr[6];
char c;
等等操作都属于静态开辟内存
进栈
void staticAction() {int arr[5]; // 静态开辟 栈区 栈成员
}
函数的末尾会弹栈隐士执行完毕会弹栈 会释放所有的栈成员
栈区占用内存大小 最大值 大概 2M 大于2M会栈溢出 平台有关系的
堆区占用内存大小 最大值 大概80% 40M没有任何问题基本上不用担心 堆区很大的
大概80% Windows系统 给我们的编译器给予的空间 的 百分之百八十
12动态开辟
使用malloc函数可以动态开辟内存这种方式的空间属于在堆中开辟函数执行完毕之后不会释放堆空间因此我们一定要手动释放free并把指针指向NULL。避免悬空指针。
悬空指针指针指向一块内存如果这块内存稍后被操作系统回收被释放但是指针仍然指向这块内存那么此时该指针就是“悬空指针”
void *p malloc(size);
assert(p);
free(p);
// 现在 p 是“悬空指针”
正确的写法
void *p malloc(size);
assert(p);
free(p);
// 避免“悬空指针”
p NULL;
野指针是没有被初始化过的指针所以不确定指针具体指向
void *p; // 此时 p 是“野指针”
因为“野指针”可能指向任意内存段因此它可能会损坏正常的数据也有可能引发其他未知错误。在实际的C语言程序开发中定义指针时一般都要尽量避免“野指针”的出现可通过赋初值方式解决
void *p NULL;
void *data malloc(size);
下面再来讲讲动态开辟 int * arr malloc(1 * 1024 * 1024); // 堆区开辟 4Mfree(arr); // 释放掉arr NULL; // 重新指向一块内存地址00000
realloc:前面已经开辟的空间使用realloc可以扩展空间大小举例如下动态开辟一个大小为5的数组
int * arr (int *) malloc(5);
for (int i 0; i 5; i) {arr[i] (i 10001);
}//使用realloc 将arr扩展为大小为11的数组
int * new_arr (int *) realloc(arr, 56);int j 5; // 5开始
for (; j (5 6); j) { arr[j] (j 10001);
}别忘了释放
free(new_arr);
new_arr NULL;
13结构体
在C语言中结构体相当于 java中的类
结构体的定义形式为 struct 结构体名
{成员列表可以是基本的数据类型指针数组或其他结构类型
};
例如
struct Dog {// 成员char name[10];int age;char sex;};
必须要在最后写;
struct Dog dog;
这样写完成员是没有任何初始化的成员默认值 是系统值乱码赋值操作strcpy(dog.name, 旺财);
dog.age 3;
dog.sex G;
第二种写法
struct Person {// 成员char * name; // 字符指针 赋值int age;char sex;
} ppp {zhangsan, 33, W};
结构体指针
struct Cat {char name[10];int age;
};int main() { // 栈// 结构体struct Cat cat {小花猫, 2};// 结构体 指针 - 调用一级指针成员struct Cat * catp cat;catp-age 3;strcpy(catp-name, 小花猫2);printf(name:%s, age:%d \n, catp-name, catp-age);return 0;
}
结构体指针与动态内存开辟
struct Cat {char name[10];int age;
};int main() { // 堆// VS的写法Cat * cat (Cat *) malloc(sizeof(Cat));struct Cat *cat malloc(sizeof(struct Cat));strcpy(cat-name, 金色猫);cat-age 5;printf(name:%s, age:%d \n, cat-name, cat-age);// 堆区的必须释放free(cat);cat NULL;return 0;
}
14结构体取别名
struct Student_{char name[10];int age;char sex;
};typedef struct Student_Student_; // 给结构体取别名typedef Student_* Student; // 给结构体指针取别名
