1.类与结构体
二者用法差不多,一般习惯庞大数据体定义为类,一些简单数据组合定义为结构体;
class 默认私有 / struct 默认共有
1.1类的定义
class 类名
{
private: //私有成员,只能在内部调用,main中不能访问
类型名 变量名 ;
public: //共有成员
类型名 变量名;
返回值类型 函数名()//成员函数
{
}
函数名(参数){} //构造函数,可以定义多个,函数名必须与类名一样
};
1.2定义成员函数:
返回类型::类名()
- 可以加{}在class里面定义
- 可以在类外面定义:返回类型::类名()
//写法一
class Time
{
private:
int hour,minute,second;
public:
Time(int h, int m, int s); //构造函数,可以有多个
Time() {} //加{}表示已经完成定义,下面不用再定义
void showtime(); //成员函数,有返回类型
};
Time::Time(int h, int m, int s)//定义构造函数
{
hour=h; minute=m; second=s;
}
void Time::showtime()
{
cout<<hour<<":"<<minute<<":"<<second<<endl;
}
//写法二
class Time
{
private:
int hour,minute,second;
public:
Time(int h, int m, int s):hour(h),minute(m),second(s){} //定义构造函数
void showtime() //声明并定义成员函数
{
cout<<hour<<":"<<minute<<":"<<second<<endl;
}
};
1.3类的调用
1. 类名 对象名 //这个变量可以自己定义
对象名 . 成员名
2. 指针 -> 成员名
Time c; Time * p = &c; p ->showtime();//作用在p指向的对象c上
3. 引用名 . 成员名
调用构造函数,必须把参数加上,可以初始化私有成员。
class Time
{
private:
int hour,minute,second;
public:
Time(int h, int m, int s); //构造函数
void showtime(); //成员函数,有返回类型
};
Time::Time(int h, int m, int s)//定义构造函数
{
hour=h; minute=m; second=s;
}
void Time::showtime()
{
cout<<hour<<":"<<minute<<":"<<second<<endl;
}
//类的实现
int main()
{
Time t(10,10,10); //构造函数参数必须都加上
t.showtime();
}
2.指针与引用
2.1指针
指针指向存放变量的地址,通过指针来修改变量的值。
可以理解为指针就是以变量地址为数组下标的那个数组
int* p //定义int类型的指针---p的类型是 int*
int* p = &a //p指向a的地址
cout<< *p <<endl; //指向a的地址的值
cout<< p <<endl; //输出a的地址
#include<iostream>
using namespace std;
int main()
{
int a=10;
int* p = &a; //定义指针p指向a的地址
cout<<*p<<endl; // 输出a的值
*p=12; //通过指针更改a的值
cout<<*p<<endl;
cout<<a<<endl;
}
输出:10
12
12
2.2指针的运算
数组本质也是指针,指针也可以运算。
int a[5]={1,2,3};
int* p=a;
cout<<*(p+2)<<endl;//输出a[2]的值 *(p+2)等价于*(a+2)
cout<<p+1<<endl; //输出a[1]的地址 等价于a+1
char* 默认输出字符串,若要输出地址 用(void*)
char a[5] ={1,2,3,4,5};
char* p = a;
cout<<(void*)p<<endl;
//输出a[0]的地址
指针地址的减法:
不允许不同类型的指针相减。
int a[5] = {0};
int* p = &a[0], *q = &a[2];//指针是int类型
cout<< q - p <<endl; //地址的减法,得到的是两个地址间隔几个int。
输出:2
2.3 指针的指针(算法少用)
存放指针的地址
int a = 10;
int* p = &a; //p的值是a的地址
int** q = &p;//q指向*p的地址
2.4 引用
与指针类似,相当于变量的别名。
int& p = a;//定义p,p和a在一个地址,二者共同,p改变a也变,a改变p也变
int a=10;
int& p=a;
p++;
cout<<a<<endl;//a=11,p=11
3.链表
定义一个结构体:struct 结构名{ };
结构体内定义指针:结构名* 变量名;
定义一个链表结点:Node node = Node (1); //链表结点是1
Node* p = Node(1);//Node类型变量,值是1
Node* p = new Node (1);
struct Node //定义结构体
{
int val;
Node* next;//定义指针
Node(int_val):(val(_val),next(NULL){} //构造函数,指针为空
};
int main()
{
Node node = Node(1);//定义Node类型的变量,返回的是值 ,把1赋给val
Node* p = new Node(1);//返回的是地址
p->next = p;//next指向自己
}
1. 定义变量来调用成员 用 " . "
Node a = Node (1);
a.next, a.val;
2. 定义指针来调用成员 用 " -> "
Node* p = new Node(1) ;
p-> next = p ;
p -> val ;
链表的使用:
删除链表:要知道前一个才可以。在遍历的时候,遍历不到即删除。(跳过去这个点)
struct Node //定义结构体
{
int val;
Node* next;//定义指针
Node(int_val):(val(_val),next(NULL){} //构造函数
};
int main()
{
Node* p = new Node(1); //Node*可以写成auto
Node* q = new Node(2);
Node* o = new Node(3);
p->next = q; //头结点,第一个结点的地址,不是值。p的指针指向q
q->next = o; //q指针指向o,o指向空
Node* head = p; //头结点
//添加节点
head* u = new Node(4);
u->next = head;
head = u;
//删除节点
head->next = head->next->next;
//遍历链表
for(Node* i = head;i;i = i->next)
cout<< i->val <<endl;
}
会输出:1 \n 2\n 3\n