#include<stdio.h>
#include<stdlib.h>
int main ()
{
char *p=malloc(1000);
//报错语句;
if(p==NULL){
perror("malloc");
exit(-1);
}
p[0]='A';
free(p);
//释放就是登记注销;
//占有空间就是登记一下
//当free()释放后;所以除非进程结束,否则空间是不会释放的
return 0;
}
//
#include <stdio.h>
int *func(void)
{
int a;
// return &a;
int *p=malloc(4);//堆段的空间,只有free去释放或者程序结束所有内存释放,并不会随着子函数的消失而消失;
if(!p){
perror("malloc");
exit(-1);
}//如果创建不成功的时候;
return p;
}
int main(void)
{
int *p=func();//在主函数定义的函数地址应该在;占空间
//用malloc定义的函数是定义在堆中,再定义就是在栈往下压,堆往上堆的位置;
free (p);
return 0;
}
#include <stdio.h>
int main(void)
{
char buf[10001];
char buf[];//这个字符数组在编译的时候由于main栈里的静态内存空间特性;
//存在一次10000个字符输入,他的内存就被打到10000的高度,以后每次只要打不到这个高度;
//main栈内的内存就这么大了;
int i=0;
while(i++<100){
scanf("%s",buf);
printf("%s\n",buf);
}
return 0;
}
静态内存空间:编译器首先读的是int 等的数据类型 ;编译器在编译时,先读的是有几个数据类型;根据多少变量
这些数据类型加起来是多少字节数,需要开辟多少内存空间;先开了main栈内的内存空间;
main 栈里的局部变量有多大
typedef int int_t
type struct{
name[]
}
通过程序,操作文件;文件在硬盘;内部存储:CPU,内存条,扩展内存条;
读 文件->内存
写 内存->文件
fileopen
File* fopen(const void *restrict ptr,size_t size,size_t nite ms,FILE *restrict stream);
FILE *结构体 ==>是一个结构体的宏;
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE * fp=fopen("./file","r");//当前文件的下的目录
/5/以只读的方式打开;可能报错
if(!fp){
perror("fopen");
exit(-1);
}
//file可能不存在,可能临时删掉了,还有有没有权限去打开file
但是程序是没有权限的,权限是用户的,user的,如果说chmod -r file;权限拒绝
permission denied 权限拒绝;
sudo whoami;//听着像so do who am i在这一瞬间获得root 权限;root权限是根目录权限
可以打开所有文件;
执行这个程序的用户,他的权限才是打开这个文件的前提;
读取有一个函数叫做size_t fread(void *restrict ptr,size_t size,size_t nitems
file)
char buf[64]={};
fread(buf,1,63,fp);fp就代表着文件//任意地址;
size_t ret=fread(buf,1,63,fp);
printf("%s,%d");
fclose(fp);
return;
}
#include <stdio.h>
int main(void)
{
int
size_t fwrite(const void *restrict ptr,size_t size,size_t nite ms,FILE *restrict stream);
int main(void){
FILE *fp=fopen("./file","w");//不存在,创建;存在,清空;重写 "r+","a+","l+"
FILE *fp=fopen("./file","a");//append:追加内容;
if(!fp){
perror("fopen");
exit(-1);
}
fwrite("hello qianfeng\n",1,strlen("hello qianfeng"),fp);
fwrite("hello qianfeng\n",1,strlen("hello qianfeng"),fp);
//再写是不会覆盖所写的内容的;append:意思不会将打开的文件清空,
而是往打开的文件中追加内容;
//第一个fwrite
fclose(fp);
return 0;
}
写一个文件copy的内容
#include <stdio.h>
#include <stdlib.h>//标准库里面已经定义好的一些宏FILE,typedef等size_t
//在文件操作过程中直接引用;
int main(void)
{
char buf[20];
FILE *fp=fopen("./file","r");打开file2
if(!fp){
perror("fopen");
exit(-1);
}
FILE *fp2=fopen("fopen_2","w");
if(!fp2){
perror("fopen");
exit(-1);
}
while (1){
size_t ret=fread(buf,1,20,fp);
if(ret<=0){
break;
fwrite(buf,1,ret,fp2);//每循环一次,fw一次1*ret内容写到fp2文件夹中;fw语句;
}
fclose(fp);
fclose(fp2);
return;
}
char
空间占用都是10001个字节;
数组占有多大的空间是我们编译代码的时候决定是10001个字节
堆段;
栈段;
栈空间:静态内存空间;空间是编译代码的时候决定的;
是编译器在读取main栈中的局部变量有多大;
由编译器决定的,在不同编译器下,静态内存是不同的
栈 数据 只读数据段//程序结束
自动释放;
当main栈产生之后;是不会修改的,固定了的
动态内存空间:空间大小是运行时决定的
由程序员分配的
堆段
手动写free()释放就可以了
动态内存空间先读一个数;
int n;
int i=0;
while(i++<100){
scanf("%d",&n);//输入n; n就创建n+1个字节
char * buf=malloc(n+1);//加个尾零
if(!p){
perror("malloc");
exit(-1);
}
scanf("%s",buf);
printf("%s\n",buf);
free(buf);//立即释放;可以随时调整我空间的大小
}
return 0;
}
#include<stdlib.h>
int main ()
{
char *p=malloc(1000);
//报错语句;
if(p==NULL){
perror("malloc");
exit(-1);
}
p[0]='A';
free(p);
//释放就是登记注销;
//占有空间就是登记一下
//当free()释放后;所以除非进程结束,否则空间是不会释放的
return 0;
}
//
#include <stdio.h>
int *func(void)
{
int a;
// return &a;
int *p=malloc(4);//堆段的空间,只有free去释放或者程序结束所有内存释放,并不会随着子函数的消失而消失;
if(!p){
perror("malloc");
exit(-1);
}//如果创建不成功的时候;
return p;
}
int main(void)
{
int *p=func();//在主函数定义的函数地址应该在;占空间
//用malloc定义的函数是定义在堆中,再定义就是在栈往下压,堆往上堆的位置;
free (p);
return 0;
}
#include <stdio.h>
int main(void)
{
char buf[10001];
char buf[];//这个字符数组在编译的时候由于main栈里的静态内存空间特性;
//存在一次10000个字符输入,他的内存就被打到10000的高度,以后每次只要打不到这个高度;
//main栈内的内存就这么大了;
int i=0;
while(i++<100){
scanf("%s",buf);
printf("%s\n",buf);
}
return 0;
}
静态内存空间:编译器首先读的是int 等的数据类型 ;编译器在编译时,先读的是有几个数据类型;根据多少变量
这些数据类型加起来是多少字节数,需要开辟多少内存空间;先开了main栈内的内存空间;
main 栈里的局部变量有多大
typedef int int_t
type struct{
name[]
}
通过程序,操作文件;文件在硬盘;内部存储:CPU,内存条,扩展内存条;
读 文件->内存
写 内存->文件
fileopen
File* fopen(const void *restrict ptr,size_t size,size_t nite ms,FILE *restrict stream);
FILE *结构体 ==>是一个结构体的宏;
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE * fp=fopen("./file","r");//当前文件的下的目录
/5/以只读的方式打开;可能报错
if(!fp){
perror("fopen");
exit(-1);
}
//file可能不存在,可能临时删掉了,还有有没有权限去打开file
但是程序是没有权限的,权限是用户的,user的,如果说chmod -r file;权限拒绝
permission denied 权限拒绝;
sudo whoami;//听着像so do who am i在这一瞬间获得root 权限;root权限是根目录权限
可以打开所有文件;
执行这个程序的用户,他的权限才是打开这个文件的前提;
读取有一个函数叫做size_t fread(void *restrict ptr,size_t size,size_t nitems
file)
char buf[64]={};
fread(buf,1,63,fp);fp就代表着文件//任意地址;
size_t ret=fread(buf,1,63,fp);
printf("%s,%d");
fclose(fp);
return;
}
#include <stdio.h>
int main(void)
{
int
size_t fwrite(const void *restrict ptr,size_t size,size_t nite ms,FILE *restrict stream);
int main(void){
FILE *fp=fopen("./file","w");//不存在,创建;存在,清空;重写 "r+","a+","l+"
FILE *fp=fopen("./file","a");//append:追加内容;
if(!fp){
perror("fopen");
exit(-1);
}
fwrite("hello qianfeng\n",1,strlen("hello qianfeng"),fp);
fwrite("hello qianfeng\n",1,strlen("hello qianfeng"),fp);
//再写是不会覆盖所写的内容的;append:意思不会将打开的文件清空,
而是往打开的文件中追加内容;
//第一个fwrite
fclose(fp);
return 0;
}
写一个文件copy的内容
#include <stdio.h>
#include <stdlib.h>//标准库里面已经定义好的一些宏FILE,typedef等size_t
//在文件操作过程中直接引用;
int main(void)
{
char buf[20];
FILE *fp=fopen("./file","r");打开file2
if(!fp){
perror("fopen");
exit(-1);
}
FILE *fp2=fopen("fopen_2","w");
if(!fp2){
perror("fopen");
exit(-1);
}
while (1){
size_t ret=fread(buf,1,20,fp);
if(ret<=0){
break;
fwrite(buf,1,ret,fp2);//每循环一次,fw一次1*ret内容写到fp2文件夹中;fw语句;
}
fclose(fp);
fclose(fp2);
return;
}
char
空间占用都是10001个字节;
数组占有多大的空间是我们编译代码的时候决定是10001个字节
堆段;
栈段;
栈空间:静态内存空间;空间是编译代码的时候决定的;
是编译器在读取main栈中的局部变量有多大;
由编译器决定的,在不同编译器下,静态内存是不同的
栈 数据 只读数据段//程序结束
自动释放;
当main栈产生之后;是不会修改的,固定了的
动态内存空间:空间大小是运行时决定的
由程序员分配的
堆段
手动写free()释放就可以了
动态内存空间先读一个数;
int n;
int i=0;
while(i++<100){
scanf("%d",&n);//输入n; n就创建n+1个字节
char * buf=malloc(n+1);//加个尾零
if(!p){
perror("malloc");
exit(-1);
}
scanf("%s",buf);
printf("%s\n",buf);
free(buf);//立即释放;可以随时调整我空间的大小
}
return 0;
}