仙桃网站制作网站设计,零基础wordpress 知乎,wordpress user level,wordpress新闻抓取插件1.c的类
1.1.c的类关键点 c类型的关键点在于类存在继承。在此基础上#xff0c;类存在构造#xff0c;赋值#xff0c;析构三类通用的关键行为。 类型提供了构造函数#xff0c;赋值运算符#xff0c;析构函数来让我们控制三类通用行为的具体表现。 为了清楚的说明类的构…1.c的类
1.1.c的类关键点 c类型的关键点在于类存在继承。在此基础上类存在构造赋值析构三类通用的关键行为。 类型提供了构造函数赋值运算符析构函数来让我们控制三类通用行为的具体表现。 为了清楚的说明类的构造析构赋值行为。我们采用一个具体的实例来验证这种行为。
// test.h
#include iostreamclass Norm1
{
public:Norm1() {printf(Norm1()_%c\n, m_i);}Norm1(char i):m_i(i) {printf(Norm1(int)_%c\n, m_i);}Norm1(const Norm1 a):m_i(a.m_i){printf(Norm1(const Norm1)_%c\n, m_i);}Norm1(Norm1 a):m_i(a.m_i) {printf(Norm1(Norm1)_%c\n, m_i);}Norm1 operator(const Norm1 a){m_i a.m_i;printf(Norm1(const Norm1)_%c\n, m_i);return *this;}Norm1 operator(Norm1 a){m_i a.m_i;printf(Norm1(Norm1)_%c\n, m_i);return *this;}~Norm1(){printf(~Norm1()_%c\n, m_i);}
private:char m_i;
};class Norm2
{
public:Norm2() {printf(Norm2()_%c\n, m_i);}Norm2(char i):m_i(i) {printf(Norm2(int)_%c\n, m_i);}Norm2(const Norm2 a):m_i(a.m_i){printf(Norm2(const Norm2)_%c\n, m_i);}Norm2(Norm2 a):m_i(a.m_i) {printf(Norm2(Norm2)_%c\n, m_i);}Norm2 operator(const Norm2 a){m_i a.m_i;printf(Norm2(const Norm2)_%c\n, m_i);return *this;}Norm2 operator(Norm2 a){m_i a.m_i;printf(Norm2(Norm2)_%c\n, m_i);return *this;}~Norm2(){printf(~Norm2()_%c\n, m_i);}
private:char m_i;
};class Base
{
public:Base():m_n2(b),m_n1(b) {printf(Base()\n);}Base(char i):m_n2(i),m_n1(i) {printf(Base(int)\n);}Base(const Base a):m_n2(a.m_n2), m_n1(a.m_n1){printf(Base(const Base)\n);}Base(Base a):m_n2(a.m_n2),m_n1(a.m_n1) {printf(Base(Base)\n);}Base operator(const Base a){m_n1 a.m_n1;m_n2 a.m_n2;printf(Base(const Base)\n);return *this;}Base operator(Base a){m_n1 a.m_n1;m_n2 a.m_n2;printf(Base(Base)\n);return *this;}~Base(){printf(~Base()\n);}
private:Norm1 m_n1;Norm2 m_n2;
};class A : public Base
{
public:A():Base(b),m_n1(a),m_n2(a) {printf(A()\n);}A(char i): Base(i),m_n1(i),m_n2(i) {printf(A(int)\n);}A(const A a):Base(a),m_n1(a.m_n1),m_n2(a.m_n2){printf(A(const A)\n);}A(A a):Base(a),m_n1(a.m_n1),m_n2(a.m_n2) {printf(A(A)\n);}A operator(const A a){Base::operator(a);m_n1 a.m_n1;m_n2 a.m_n2;printf(A(const A)\n);return *this;}A operator(A a){Base::operator(a);m_n1 a.m_n1;m_n2 a.m_n2;printf(A(A)\n);return *this;}~A(){printf(~A()\n);}
private:Norm1 m_n1;Norm2 m_n2;
};2.关于类的构造
2.1.构造函数执行顺序
#include test.h
int main()
{A a1;return 0;
}上述代码编译运行后的输出
这是因为对任意一个c类型A其构造顺序为 1.基类构造 2.成员变量按类内出现顺序构造 3.类自身的构造函数体 上述定义一个递归式的定义。
2.2.默认构造 (1).定义 不需要传递任何参数即可执行的构造函数称为默认构造。
class A1
{
public:A1(){}
};class A2
{
public:A2(int i 0){}
};上述A1()算默认构造A2(int i 0)也算默认构造。因为这些构造函数可以不用传递任何实参即可执行。如A1 a1;A2 a2;将分别执行上述构造函数。
(2).合成版本 a.当一个c类型定义中用户没有自定义任何构造函数时编译器默认为其提供一个默认构造函数。
#include iostream
class A
{
public:A(const A){printf(A(const A)\n);}
};int main()
{A a;// err因为已经存在自定义构造函数无合成版本return 0;
}b.默认构造函数可行的前提是 1.基类支持默认构造 2.类的所有成员变量支持默认构造
#include iostream
class T
{
private:T(){}
};class A
{
public:private:T t;
};int main()
{A a;// err因为类的成员t对A来说不支持默认构造return 0;
}c.合成的默认构造的行为 1.基类默认构造 2.成员变量按类内出现顺序执行默认构造 3.类自身的构造函数体合成下函数体为空 上述定义是一个递归式的定义。
(3).显式请求合成版本 当用户自定义了构造函数而我们依然希望编译器提供合成版本默认构造时可以用下述方式
#include iostreamclass A
{
public:A(int i){printf(A(int)\n);}A()default;
};int main()
{A a;return 0;
}3.拷贝构造
拷贝构造其实就是构造的一种类型。但是使用比较频繁故单独拿出来再说一遍。 3.1.拷贝构造执行顺序 拷贝构造依然属于构造所以遵循构造执行顺序。
#include test.h
int main()
{A a1;A a2(a1);return 0;
}上述代码编译后输出为 其中蓝色部分对应A a2(a1);这是因为对任意一个c类型A其拷贝构造顺序为 1.基类构造 2.成员变量按类内出现顺序构造 3.类自身的构造函数体 上述定义一个递归式的定义。
A的基础类型A的成员变量的构造可能存在多个版本具体采用那个版本呢 1.匹配到的A的构造函数中构造列表指定了如何构造下以构造列表中指定的为准。 2.匹配到的A的构造函数中构造列表未指定时采用类型的默认构造。
3.2.默认构造 (1).定义 只需要传递类型自身一个实例即可执行的构造函数称为拷贝构造。
class A1
{
public:A1(const A1 a){}A1() default;
};class A2
{
public:A2(const A2 a, int i 0){}A2() default;
};上述A1(const A1 a)算默认构造A2(const A2 a, int i 0)也算默认构造。因为这些构造函数只需要传递类型自身一个实例即可执行。如A1 a1;A2 a11(a1);A2 a2;A2 a22(a2);中A2 a11(a1)和A2 a22(a2)将分别执行上述拷贝构造。
因为拷贝构造也属于构造函数所以定义了拷贝构造下若希望提供合成版本默认构造函数必须采用A1()default这样的方式显式请求。
(2).合成版本 a.对于拷贝构造不同于默认构造。 默认构造是只要存在任何构造函数就不会提供编译器合成的默认构造版本。 拷贝构造允许存在其他构造函数只要用户没有定义只接收自身实例即可执行的构造函数编译器就会提供合成的拷贝构造。
b.合成版本行为表现
#include test.h
class B : public Base
{
public:
private:Norm1 m_n1;Norm2 m_n2;
};int main()
{B b1;B b2(b1);return 0;
}上述输出中红色对于合成版本默认构造。蓝色对应合成版本拷贝构造。 合成拷贝构造下构造顺序依然是 1.基类构造 2.成员变量按类内出现顺序构造 3.类自身的构造函数体 上述定义一个递归式的定义。
不过此时对基类执行的是基类的拷贝构造。对成员变量执行的也是其拷贝构造。类自身的拷贝构造函数体是空的。
c.默认构造函数可行的前提是 1.基类支持拷贝构造 2.类的所有成员变量支持拷贝构造
#include iostream
class T
{
public:T(){}
private:T(T t){}
};class A
{
public:private:T t;
};int main()
{A a;A a2(a);// err因为A的成员t不支持拷贝构造。return 0;
}(3).显式请求合成版本 拷贝构造严格来说没有显式请求的必要因为只要用户没有通过只接收类型自身实例即可执行的构造函数编译器总是会提供合成的拷贝构造。
4.关于类的赋值
4.1.赋值顺序
#include test.h
int main()
{A a1;A a2;a2 a1;return 0;
}上述紫红色的123对应a2a1; 值得注意的是赋值运算符不像构造函数析构函数。 像构造函数无论如何总是会对基类执行构造对类的成员执行构造。类的定义者只能通过构造初始化列表决定采用那个版本的基类构造成员构造。但基类构造成员构造作为两个执行阶段无论针对合成版本构造函数还是用户自定义的构造函数总是存在的。 对赋值如何用户自定义了赋值运算符则基类部分赋值成员赋值全部依赖自定义函数体的实现。 上述紫红色包含123的原因是我们提供的自定义赋值运算符里面分别处理了基类赋值成员赋值。
class A : public Base
{
public:A operator(const A a){Base::operator(a);m_n1 a.m_n1;m_n2 a.m_n2;printf(A(const A)\n);return *this;}private:Norm1 m_n1;Norm2 m_n2;
};4.2.默认赋值运算符 (1).定义 赋值运算符属于运算符的范畴其定义形式有相对较为严格的要求
class A1
{
public:A1 operator(const A1 a){... }
};
作为赋值运算符 1.返回值必须是类型自身的引用类型。 2.只能接收一个形参。 3.传递类型自身实例时可以匹配到形参。所以下述也是合法的自定义赋值运算符。
class A1
{
public:A1 operator(A1 a){... }
};(2).合成版本 a.何时合成 用户没有自定义赋值运算符时。
b.合成版本行为表现
#include test.h
class B : public A
{
private:Norm1 n1;
};int main()
{B b1;B b2 b1;return 0;
}上述紫红色12对应B的合成版本赋值运算符。 合成的赋值运算符 1.通过基类赋值运算符完成基类赋值。 2.对每个成员执行其赋值运算符完成成员赋值。
c.合成版本可行的前提是 1.基类支持赋值运算符 2.类的所有成员变量支持赋值运算符
#include iostream
class T
{
public:T(){}
private:T operator(T){}
};class A
{
public:private:T t;
};int main()
{A a1;A a2;a2 a1;// err因为A的成员t不支持赋值运算符t的赋值运算符对A不可见return 0;
}(3).显式请求合成版本 赋值运算符严格来说没有显式请求的必要因为只要用户没有定义赋值运算符编译器总是会提供合成的赋值运算符。
4.关于类的析构
4.1.析构顺序
#include test.h
int main()
{A a;return 0;
}上述蓝色123对应A a;中实例a的析构过程。 析构函数执行顺序为 1.类自身的析构函数体 2.成员变量按类内出现顺序反向析构 3.基类析构 上述定义一个递归式的定义。
不像构造函数析构函数没有初始值列表这样的东西。每个类型的析构函数也不存在多个版本。
4.2.合成版本 a.何时合成 只要用户没有自定义析构函数编译器就会合成析构函数。
b.合成版本行为表现 1.类自身的析构函数体。合成版本函数体为空。 2.成员变量按类内出现顺序反向析构 3.基类析构 上述定义一个递归式的定义。
c.合成版本可行前提 1.类的基类支持析构 2.类的成员支持析构
4.3.显式请求合成版本 析构函数严格来说没有显式请求的必要因为只要用户没有定义析构函数编译器总是会提供合成的析构函数。
