1.类
面向对象三个基本特征:封装、继承、多态。
其实类跟结构体差不多(结构体是类的一个特定情况),只不过关键字是class。
类:具有同种属性的对象称为类,是个抽象的概念。比如说:汽车、人、狗、神;
对象:日常生活中的所有东西都是对象,是类的实例化。比如说:推土车是汽车的实例化;姚明是人的实例化;小白(狗的名字)是狗的实例化;二郎神是神的实例化;
属性:用来描述具体某个对象的特征的是属性,是静态的。比如:姚明身高2.6米多;小白的毛发是棕色的;二郎神额头上有只眼睛;
方法:每个对象有它们自己的行为或者是使用它们的方法,比如说一只狗会跑会叫等,我们把这些行为称之为方法,是动态的,可以使用这些方法来操作一个对象;
类的成员:属性和方法称为这个对象的成员,因为它们是构成一个对象的主要部分,没有了这两样东西,那么对象也没什么存在意义了。
2.声明
不能直接在类里给变量赋初值,但是可以在类里定义一个函数,在这函数内给变量赋初值。
3.关键字
4.友元
作用范围:整个类
class CP
{
private:
void fun1()
{
cout << "fun1" << endl;
}
//不管放在哪,其范围都是整个类
friend void fun3();
private:
int a;
void fun2()
{
cout << "fun2" << endl;
}
}
void fun3()
{
CP Cp;
Cp.fun1();
Cp.a = 1;
Cp.fun2();
}
int main(void)
{
fun3();
system("pause");
return 0;
}
5.抽象类和接口
面对对象的设计,复用的重点其实应该是抽象层的复用,而不是具体某一个代码块的复用。 抽象类要被子类继承,接口要被子类实现。抽象类既可以对方法进行声明也可以对方法进行实现,接口里面只能对方法进行声明(就是在abstract class中既可以有方法的具体实现,又可以没有具体实现的抽象方法;而在interface中只能定义方法,而不能有方法的实现),这说明接口是设计的结果,抽象类是重构的结果。
抽象类主要是用来抽象类别,接口主要是用来抽象方法功能。当你关注事物的本质的时候,请用抽象类;当你关注一种操作的时候,用接口。
在使用方法上,如果向一个抽象类里加入一个新的具体方法时,那么它所有的子类都一下子都得到了这个新方法,而接口做不到这一点,如果向一个接口里加入一个新方法,所有实现这个接口的类就无法成功通过编译了,因为你必须让每一个类都再实现这个方法才行,这显然是接口的缺点。
使用抽象类,那么继承这个抽象类的子类类型就比较单一,因为子类只能单继承抽象类;而子类能够同时实现多个接口,类型就比较多。接口和抽象类都可以定义对象,但是只能用他们的具体实现类来进行实例化。
这里以JAVA举个栗子(理解两个类的区别即可,与语言无关):
抽象类AbstractAction (JAVA)
public abstract class AbstractAction implements Action, InitializingBean {
protected final Log logger = LogFactory.getLog(getClass());
//定义方法(没有具体实现的方法)
public Event execute(RequestContext context) throws Exception;
//具体实现的方法
public void afterPropertiesSet() throws Exception {
try {
initAction();
} catch (Exception ex) {
throw new BeanInitializationException("Initialization of this Action failed: "
+ ex.getMessage(), ex);
}
}
具体的接口Action (JAVA)
public interface Action {
//只有定义方法(没有具体实现的方法)
public Event execute(RequestContext context) throws Exception;
}
6.函数对象
6.1 构造函数
在对象创建的时候调用。可以用来给类里面的变量赋初值(结构体没有此功能),无返回值。
class CStu
{
public:
//构造函数:自动调用
CStu() //没有返回值
{
age = 12;
f = 12.12f;
}
};
//也可以指定默认值
class CStu
{
public:
CStu(int = 12)
{
age = a;
f = 12.12f;
}
};
注意:成员初始化顺序只与声明的顺序有关,跟初始化列表的书写顺序无关。
6.2 析构函数
在对象释放前的时候调用。可以用来释放new出来的内存,无返回值。
class CStu
{
public:
~CStu()
{
cout << "析构函数" << endl;
delete pp;
}
};
6.3 类指针this
class CStu
{
public:
int a;
//this不是成员,是类成员函数的隐含参数
//this -> a 是类的a,而没写this的是局部的a
CStu(int a)
{
this->a = a; //将局部的 a 赋值给 类的a
this->Show();
}
void Show()
{
cout << a << endl;
this->a;
}
};
6.4 常函数
int a = 0;
class CStu
{
public:
int a;
void Show() const
{
this->a = 13; //会报错,因为常函数里面是不允许修改数据成员的
int b;
b = 13; //可以,常函数允许内部的数据修改
}
};
6.5 static
整型: char、short、int、long、long long。
在类创建时,静态就已经分配好空间了 (静态的生命周期是跟整个程序共存亡的)。
所以没创建对象时,也可以调用静态变量或函数。
所以其没有this指针,静态函数也不能调用非静态变量。
有个有趣的例子,不使用循环对变量自加 5 次:
#include <iostream>
using namespace std;
class CStu
{
public:
static int b;
CStu()//:a(2)
{
b++;
}
};
int main()
{
CStu st[5]; //因为每个对象都是公用静态变量,所以b++会执行五次
system("pause");
return 0;
}
6.6浅拷贝
class CStu
{
public:
CStu()
{
}
CStu(const CStu& a)
{
}
};
int main()
{
CStu st1;
CStu stNew(st1); //当然也可以 CStu stNew = st1; 会更方便
system("pause");
return 0;
}
在上面的代码中,stNew创建时不会调用第一个构造CStu()
如果没有自写的拷贝构造 CStu(const CStu&a),则默认的拷贝构造会自动把st1的值拷贝到stNew中。如果有自写拷贝构造 CStu(const CStu&a) ,则会调用此拷贝构造函数,但如果函数里什么都不写,那么stNew是不会被赋值的。
浅拷贝所存在的问题(重复释放空间):
class CStu
{
public:
int *a;
CStu()
{
a = new int[2];
a[0] = 12;
a[1] = 13;
}
~CStu()
{
delete[] a;
}
}
int main(void)
{
{
CStu at;
CStu st = at; //浅拷贝
}//程序跑到这里后, at 和 st 都被释放
}
因为浅拷贝是直接把 at 里的值全部拷贝到 st 里,所以 at.a 和 st.a 指针变量其实是同一内存同一地址。当 at 结束时析构函数会释放 at.a ,当st 结束时析构函数又会释放 st.a,即 a 内存释放了两次!
浅拷贝只是对指针的拷贝,拷贝后两个指针指向同一个内存空间。
6.7 深拷贝
为了解决浅拷贝的问题,深拷贝不但对指针进行拷贝,而且对指针指向的内容进行拷贝,经深拷贝后的指针是指向两个不同地址的指针。
思路:在构造函数里重新申请一个空间,然后把内存贝到新的空间去(用memcpy来拷贝更方便):
class CStu
{
public:
int *a;
CStu()
{
a = new int[2];
a[0] = 12;
a[1] = 13;
}
CStu(const CStu& b)
{
//申请空间
this->a = new int[2];
//将值拷贝到新的内存空间
//也可以用 memcpy(this->a, b.a, 8);
this->a[0] = b.a[0];
this->a[1] = b.a[1];
}
~CStu()
{
delete[] a;
}
}
int main(void)
{
{
CStu at;
CStu st = at; //浅拷贝
}//程序跑到这里后, at 和 st 都被释放
}
6.8 内联函数
常规函数是以时间换空间,而内联函数是以空间换时间,两者用途不同,合理运用即可。
下一篇《C++笔记,类的继承》
个人公众号:拾一札记
参考资料:
C3程序猿:https://www.bilibili.com/video/BV1rW411R7g4