一.类的引入
c语言中,结构体只能定义变量,在C++中引入类,类中不仅能定义变量,我们称之为成员,也可以定义函数,成为成员函数。
#include<iostream>
using namespace std;
class Test
{
public:
void func()
{
cout<<Test::func()<<endl;
}
private:
int m_data;
};
在这个类中,我们有成员,还有函数,其中我们发现了两个关键词,private和public。接下来我们就深入了解一下类的更多用处吧。
二.类的定义
class为定义类的关键字,上面的代码中Test为类名,{}为类的主体。
注意:类的定义后面有;
类中的元素我们称之为成员,上述定义的数据m_data为类的属性和成员变量,类中的函数为类的方法和成员函数。
类中的访问限定符
public(公有),private(私有),protected(保护)
c++中的成员默认为私有,但是结构体中默认为公有的。
public修饰的成员我们可以在类外直接访问,但是protected和 private修饰的成员不能在类外直接访问,但是我们也可以通过其他方式间接访问,在后面我们会提到。
类的作用域
类中的所有成员都在类的作用域中,在类体外定义成员,需要使用::作用域解析符。
class Test
{
public:
void func();
private:
int m_data;
};
void Test::func()
{
cout<<m_data<<endl;
}
三.类的实例化
用类类型创建对象的过程称为实例化对象。
#include<iostream>
using namespace std;
class Test
{
public:
int Getdata()
{
cout<<m_data<<endl;
}
private:
int m_data;
};
void main()
{
Test t;//实例化对象
Test t1(10);
}
我们实例化对象的过程中需要给这个对象分配内存空间,并为其赋初值,此后结束时还会释放空间,这与后面的类的默认方法有关,我们后面再了解。
四.类的六大默认函数
构造函数:
class Test
{
public:
//构造函数
Test(int data=0)
{
m_data=data;
}
private:
int m_data;
};
void main()
{
Test t1;//实例化对象
cout<<t1.m_data<<endl;
Test t2(10);//实例化对象
}
构造函数的作用主要是申请资源,对象初始化。
构造函数的特点:
1.函数名和类名相同,没有返回值。
2.如果没有自定义的构造函数,系统会产生默认的,默认的构造函数会产生随机值。
3.构造函数的调用顺序是根据其实例化的顺序依次进行,每产生一个对象,调动一次构造函数。
拷贝构造函数
拷贝构造函数也属于构造函数。
class Test
{
public:
//构造函数
Test(int data=0)
{
m_data=data;
}
//拷贝构造函数
Test(const Test &t) //采用引用取别名,不用重新开辟空间让实参给形参赋值
{
//加const采用常引用防止内部改变参数对象的值
m_data=t.m_data;
}
private:
int m_data;
};
void main()
{
Test t1;
Test t2=t1;//调用拷贝构造函数
}
当用对象进行初始化对象时,系统会自动调用拷贝构造函数。如果不写,系统也会产生默认的拷贝构造函数,并且最终结果与上面定义的相同。
除此之外,还有一种情况我们也会调动拷贝构造函数。
class Test
{
public:
Test(int data=0)
{
m_data=data;
}
public:
int GetData()const
{
return m_data;
}
private:
int m_data;
};
Test func(Test obj)
{
int value=obj.GetData();
Test tmp(value);
return tmp;//调动拷贝构造函数
}
void main()
{
Test t1;
func(t1);//调动拷贝构造函数
}
函数的实参为实例化对象时我们将实参传给形参时,也是一种对象拷贝构造对象的过程,所以拷贝构造函数的实质就是通过对象实例化对象的过程。
除此之外,在上面代码中,我们的func函数内部返回临时值tmp时也需要调动拷贝构造函数,tmp是一个临时对象,函数结束后我们会释放这个空间,在此之前,我们需要将这个tmp拷贝到一个临时空间中保存,此时也是对象拷贝构造对象。
等号的重载
class Test
{
friend ostream& operator<<(const osteam &out,const Test &t);
public:
Test(int data=0)
{
m_data=data;
}
~Test()
{}
Test(const Test& t)
{
m_data=t.m_data;
}
Test& operator=(const Test& t)
//切记返回对象时用引用要看返回值是否是临时对象
{
if(this!=&t)
{
m_data=t.m_data;//检查是否自己给自己赋值(防止多次引用)
}
return *this;
}
private:
int m_data;
};
ostream& operator<<(const osteam &out,const Test &t)
{
out<<t.m_data;
return out;
}
void main()
{
Test t1;
Test t2(10);
t1=t2;//调用赋值语句
cout<<t1<<endl;
Test t3;
t3=t2=t1;
//t3.operator=(t2.operator=(t1));遇到连等的时候会需要返回值
//因此等号的重载需要返回值
}
运算符重载真实意义:我们在进行对某种类型变量在进行运算时,我们希望可以直接的表达,而不是通过函数的调用完成运算,运算符的重载相当于给这个运算符赋予一个其他的含义。
在我们进行类成员的重载函数时,形参中感觉少一个参数,操作符中有一个默认的this,限定为一个形参。
赋值运算符主要四点:
1.参数类型(我们有时候为了提高程序效率,经常在函数形参,返回值中引用)
2.返回值
3.检查是否自己给自己赋值
4.一个类中如果没有显示定义赋值运算符的重载,编译器也会生成一个,完成对象的按字节拷贝。
const修饰类的成员函数
class Test
{
public:
void SetData(int data)
{
m_data = data;
}
// int GetData(const Test *const this)
int GetData()const//常方法(必须是定义在类内部的方法)
{
//常方法内部不允许对数据成员进行修改
return m_data;
}
//int GetData(Test* const this)
int GetData()
{
//与以上方法形成重载(二者参数类型不同)
return m_data;
}
//两种形式可以同时存在,也可以只保留常方法
private:
int m_data;
};
void main()
{
Test t1;
t1.GetData();//常方法和普通方法同时存在时,普通对象首先选择普通方法
const Test t2; //常对象不能调动普通方法
cout << "t= " << t2.GetData() << endl;
t2.GetData();//只能调动常方法
cout << "t= " << t1.GetData() << endl;
}
将const修饰的类成员函数称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐藏的this指针,表明在该成员函数中不能对类的任何成员进行修改。
常方法内部不允许调用普通方法,普通方法内部可以调用常方法
友元
class Test
{
friend class Date;
friend void func(const Test& t);//只需要在类中声明这个方法即可
public:
Test(int data = 0)
{
m_data = data;
}
public:
int GetData()
{
return m_data;
}
private:
int m_data;
};
class Date
{
public:
Data():m_year(2001),m_month(04),m_day(17)
{}
~Data()
{}
private:
int m_year;
int m_month;
int m_day;
};
void func(const Test &t)
{
int data = t.m_data;
//由于m_data是类中私有成员,因此我们需要将此方法变为友元方法
}
友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类的公有成员。
1.友元关系是单向的,不具有传递性
比如在上述代码中,在Test类中声明Date类为其友元类,那么可以在Date类中直接访问Test类中私有成员变量,但是不能再Test类中访问Date类中的私有成员变量。
2.友元关系不能传递
如果B是A的友元,C是B的友元,也不能说明C是A的友元。