c/c++基础知识记录

数据结构类型

c/c++语言的数据结构类型分为基本数据类型和高级数据类型两种。基本数据类型分为：整型、浮点型、字符型、逻辑型。

整型
整型数据类型根据表示范围分为short、int 、long。

关键字	长度	范围
short	2字节	-2¹⁵~2¹⁵-1
unsigned short	2字节	0~2¹⁶-1
int	4字节	-2³¹~2³¹-1
unsigned int	4字节	0~2³²-1
long	4字节	-2³¹~2³¹-1
unsigned long	4字节	0~2³²-1

浮点型
浮点型数据有float、double、long double。

关键字	长度
float	4字节
double	8字节
long double	8字节

float类型数据精度为小数点后有效位6位，double类型数据精度为小数点后有效位15位。

字符型

关键字	长度	范围
char	1字节	-128~127
unsigned	1字节	0~255

逻辑类型

关键字	长度	范围
bool	1字节	true、false

局部变量
在一个函数内部或者一个复合结构（包括类）内定义的变量称为局部变量（又称内部变量），其有效范围只在所定义的函数或者结构中。
全局变量
全局变量的作用范围不仅仅局限于函数中，而是在程序的任何部分都能起作用，c++规定在函数之外定义的变量为全局变量，又称外部变量。

#include<iostram.h>
int m=1;//全局变量
int main()
{
return 0;
}

自动数据类型转换
在进行数据运算时，c++可以实现将参与运算的各个数据项从一种数据类型到另一种数据类型的自动转换。c++中各数据类型的数量级顺序是：
char–>short–>int–>long–>float–>double
强制数据类型转换
强制数据类型转换有两种方式

float(a)
(int) a

数据结构相关知识

算法时间复杂度
算法时间复杂度是算法运行时间的相对度量，语句频度是语句重复执行的次数，一个算法所耗费的时间就是该算法中所有语句频度之和。要准确计算出一个算法的语句频度有时是相当繁琐的，也是没有必要的，实际中只要大致估计出算法时间复杂度的的**数量级（order）**即可。时间的复杂度就是语句频度的数量级表示，一般只要分析算法中的循环语句重复执行的次数即可；
算法空间复杂度
算法空间的复杂度是算法所需存储的空间的度量，它是问题规模 $n$ 的函数，记为 $S (n)$ 。

链表

链表的创建与打印

#include<stdio.h>
#include<stdlib.h>
typedef struct student{
	char name[8];
	char num[10];
	int score;
	struct student *next;
}NODE;       //将struct student 结构类型定义为新的类型名NODE 
				//（我得理解是，链表是一种特殊的结构，就是形如 NODE 一样的结构体，所以用NODE表示这种特殊的结构） 
int main()
{
	 
	NODE *head;      //变量声明，定义 一个NODE结构类型的指针变量head 
	NODE *creat();   // creat函数原型申明 ，返回值类型为NODE结构指针 （该函数实现链表的创建） 
	void display(NODE*); // display 函数原型申明，形参为NODE结构指针，返回值为空 （该函数实现链表的打印） 
	
	head=creat();     //创建链表 
	display(head);    //打印链表 
	return 0;	
} 

//定义函数

NODE *creat()    
{
	NODE *head, *p, *s;   //声明三个NODE类型的指针 ，head头指针，p可以看作尾指针，s可以看作节点指针 
	int key=1,n;          //n表示链表的节点个数 
	char k[3],grad[3];    // 
	
	head=(NODE*)malloc(sizeof(NODE));  //给头指针动态分配内存地址 
	p=head;                            // 
	while(key)
	{
		printf("\nEnter serial number:");
		gets(k);
		n=atoi(k);  //类型转换成int，给n赋值 
		if(n!=0)
		{
			s=(NODE*)malloc(sizeof(NODE));  //给节点指针动态分配内存地址 
			printf("\nEnter name %d:",n);
			gets(s->name);                //给数据段赋值 
			printf("\nEnter num %d:",n);
			gets(s->num);
			printf("\nEnter grad %d:",n);
			gets(grad);
			s->score=atoi(grad);
			p->next=s;    //尾指针next指向节点的首地址 
			p=s;   // 新节点s成为新的尾指针 
		}
		else
		key=0;
	}
	head=head->next;   //head只保留指针段的地址 
	p->next=NULL;  // 末尾指针指向空地址 
	return(head);
 } 
 //链表打印 
 void display(NODE *head)
 {
 	NODE *p;
 	p=head;
 	printf("\nChain is:");
 	if(head!=NULL)
 		do{
 			printf("\n%s %s %d",p->name,p->num,p->score);
 			p=p->next;
		 }while(p!=NULL);
  }

在这里插入图片描述

用尾插法建立带头结点的单链表

调用malloc函数，生成一个头结点head，同时让尾指针s=head；
调用malloc函数，建立新的节点p；
给新节点的数据域data赋值，将新节点的指针域设置为空；
将新节点链接到链表的尾节点s之后，修改尾指针是s；
重复上述步骤2~4，直至输入结束标志0尾止；

#include<stdio.h>
#include<stdlib.h>
typedef struct  linklist{
	int data;
	struct linklist *next;
}node;                 //定义链表结构 

int main()
{
	node *head;
	node *creat();	
	void display(node*);
	head=creat();
	display(head);
	return 0;
}

//链表创建 
node *creat()
{
	node *head,*p,*s;
	int data;
	printf("input a int number to start:");
	scanf("%d",&data);
	head=(node*)malloc(sizeof(node));
	s=head;
	while(data){
		p=(node*)malloc(sizeof(node));
		printf("input a int number to linklist:");
		scanf("%d",&data);
		p->data=data;
		s->next=p;
		s=p;				
}
//	head=head->next;
	s->next=NULL;
	return(head);
}


//链表打印 
 void display(node *head)
 {
 	node *p;
 	p=head->next;
 	printf("\nChain is:");
 	if(head!=NULL)
 		do{
 			printf("\n%d",p->data);
 			p=p->next;
		 }while(p!=NULL);
  }

在这里插入图片描述

用头插法建立带头结点的单链表

调用malloc函数，生成一个头结点head，将head指针域置空；
调用malloc函数，建立新的节点p；
给新节点的数据域data赋值，将新节点的指针域指向head所指的节点；
将链表头结点head的指针域修改为新节点p；
重复上述步骤2~4，直至输入结束标志0尾止；`

#include<stdio.h>
#include<stdlib.h>
typedef struct  linklist{
	int data;
	struct linklist *next;
}node;                 //定义链表结构 

int main()
{
	node *head;
	node *creat();	
	void display(node*);
	head=creat();
	display(head);
	return 0;
}

//链表创建 
node *creat()
{
	node *head,*p;
	int data;
	printf("input a int number to linklist:");
	scanf("%d",&data);
	head=(node*)malloc(sizeof(node));
	head->next=NULL;
	while(data){
		p=(node*)malloc(sizeof(node));
		p->data=data;
		p->next=head->next;
		head->next=p;
		printf("input a int number to linklist:");
		scanf("%d",&data);				
}
	return(head);
}


//链表打印 
 void display(node *head)
 {
 	node *p;
 	p=head->next;
 	printf("\nChain is:");
 	if(head!=NULL)
 		do{
 			printf("\n%d",p->data);
 			p=p->next;
		 }while(p!=NULL);
  }

在这里插入图片描述

结构体

结构体类型
定义：这个叫做结构体类型定义

struct 结构名
{
	数据类型1 成员1；
	数据类型2 成员2；
	数据类型3 成员3；
	.....	
}；

结构体类型变量的定义

struct stu{
	int num[8];
	char name[10];
}student;

另一种方式为

struct stu student；//前提是先定义了结构体类型

指针

指针的定义

数据类型 *变量名     //  *与变量名之间无空格

定义中的 $*$ 号表示其后的变量为指针变量， $*$ 与变量名之间无空格;
定义完之后，在使用时“指针变量名”前有 $*$ 号表示该指针变量所指向的变量；“指针变量名”前无 $*$ 号表示指针变量本身，即为地址;
指针变量的值为正整数，即地址，没有其他类型的数，给指针指定数据类型意义在于表示该指针变量可以指向哪种类型的变量，即存放哪种类型变量的地址。

指针变量的赋值（初始化）

int *p,x;
p=&x;            //取地址

int x;
int *p=&x;

$*和\&$ 互为逆运算

&*p=p;  /p为指针（地址）

指针的作用

#include<stdio.h>
int main()
{   int swap1(int,int);
	int swap2(int*,int*);
	int swap3(int*,int*);
	int a=10,b=20;
	swap1(a,b);
	printf("a=%d,b=%d",a,b);
	swap2(&a,&b);
	printf("\na=%d,b=%d",a,b);
	swap3(&a,&b);
	printf("\na=%d,b=%d",a,b);
	return 0;
 }
  
int swap1(int a,int b)
{
	int c;
	c=a;
	a=b;
	b=c;	
	return 0;
} 

int swap2(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;	
	return 0;
} 

int swap3(int *a,int *b)
{
	int *t;
	t=a;
	a=b;
	b=t;	
	return 0;
}

运行结果
在这里插入图片描述

如何调用自建函数

一种比较简单的方法就是在当前.cpp程序里直接声明，然后定义，这种方法只适合新手写一些简短的代码，而且不能在其他程序中复用。在大型项目中，函数的声明和定义是分开的，调用是在其他程序中，下面就来看一下是如何在其他程序中调用自建函数。

函数的声明

声明一个求和函数add，然后把该文件保存为.h文件，名称可以任意取，我保存为add.h；上面的 _ADD_H可以自定取名。
函数的定义

另新建一个程序文件，在定义时，一定要加入头文件add.h，与上面的函数声明匹配；该文件保存为add.cpp，文件名最好与函数声明add.h文件名匹配，便于查看；
函数调用

新建一个主函数文件，记得插入头文件add.h，这里不需要进行函数的声明了，可以直接调用；三个程序就是下面这样了。

数据结构类型

数据结构相关知识

链表

结构体

指针

如何调用自建函数