框架:
#include<iostream>
class super
{
public:
int member;
//构造器,前面不能加void
super(int member);
super(const super& another);
//析构器,前面不能加void,基类最好定义为虚方法
virtual ~super();
//虚方法
virtual void operation(void);
//重载运算符
super operator+(super &anthor);
friend std::ostream& operator<<(std::ostream& os,super another);
protected://这个类和它的子类
private: //只有这个类
};
super::super(int member)
{
this->member=member;
}
super::~super()
{
}
void super::operation(void)
{
std::cout<<"A"<<std::endl;
}
//继承
class sub:public super
{
public:
int member;
sub(int member);
~sub();
void operation(void);
protected:
private:
};
sub::sub(int member):super(member){}
sub::~sub(){}
void sub::operation(void)
{
std::cout<<'B'<<std::endl;
}
//该类为抽象类，不能有实例
class other
{
//友元
friend class super;
public:
//抽象方法
virtual void abstract(void)=0;
protected:
private:
};
//抽象方法
class other2:public other
{
public:
virtual void abstract(void);
};
void other2::abstract(void)
{
std::cout<<"abstract method"<<std::endl;
}
//重载运算符
super super::operator+(super &anthor)
{
return super(member+anthor.member);
}
//重载<<运算符
std::ostream& operator<<(std::ostream& os,super another)
{
os<<another.member;
}
//副本构造器
super::super(const super& another)
{
this->member=another.member;
}
int main()
{
//虚方法
super *sub_pointer=new sub(0);
sub_pointer->operation();
//重载运算符
super A(1),B(2);
std::cout<<A+B<<std::endl;
//抽象方法
other2 C;
C.abstract();
//delete:删除数组:delete[]
delete sub_pointer;
return 0;
}
构造函数:
class super
{
public:
int member1,member2;
super(int member1,int member2);
//隐式转换构造函数
super(const int& member4):member1(member4)
{
}
//复制构造函数
super(const super& other)
{
}
};
//初始化列表
super::super(int member1,int member3):
member1(member1),member2(member3)
{
}
一般声明为public
因为创建对象一般是在外部进行的
若声明为protected或private
那就意味着在外部创建对象是错误的
只能由类内部实例化(不通常的做法)
一般来说:不应同时使用 构造函数的重载 和 带默认参数的构造函数(会产生歧义)
带默认参数的构造函数只能在类内部定义
explicit 前缀定义 构造函数防止 隐式转换，在类外部定义不能重复加explicit
继承中的访问控制:
public:继承会保留基类中成员(包括函数和变量等)的可见性不变
protected:继承会将基类中的public可见性的成员修改成为protected可见性
private:继承会将基类中的public和protected可见性的成员修改成为private可见性
不允许重载的符号:
. //成员访问运算符
.* //成员指针访问运算符
:: //域运算符
sizeof
?: //条件运算符
成员指针与成员函数指针:
#include<iostream>
class super
{
public:
int member;
super(int member)
{
this->member=member;
}
//const限定改函数不能改变成员的值
int operation(int member)const
{
return this->member;
}
};
int main()
{
//成员指针
int super::*pointer_member=&super::member;
//成员函数指针
int (super::*pointer_operation)(int member)const=&super::operation;
super A(2);
super *p=&A;
std::cout<<p->*pointer_member<<std::endl;
std::cout<<A.*pointer_member<<std::endl;
std::cout<<(p->*pointer_operation)(3)<<std::endl;
std::cout<<(A.*pointer_operation)(3)<<std::endl;
return 0;
}
const的限定:
class super1
{
public:
int member1;
super1(int member1):member1(member1){}
//可修改该常对象的值
mutable int member2;
};
//常对象(2种定义)
//所有数据成员都不能被修改
//只能调用常函数,不能调用非常函数
//不能被非常函数访问,只能被常函数访问
//只能被 指向常对象的指针 指向
const super1 A(2);
super1 const B(2);
class super2
{
//常数据成员
//只能通过构造函数的初始化列表进行初始化
//常函数与非常函数都可以访问,但不能修改
public:
//const数据成员
//既可以被常函数访问也可以被非常函数访问
const int a;
int operation(void)const;
const int operation(void);
};
//常函数
//可以访问常数据成员或非常数据成员
//不能改变数据成员的值
//不能调用非常函数
int super2::operation(void)const
{
}
//返回值为const
const int super2::operation(void)
{
}
super1 C(2);
//指向对象的常指针
//不能修改它的指向
//必须在定义的时候被初始化
super1* const p1=&C;
//指向常对象的指针
//不能通过它改变指向对象的值
//可以改变指向
const super1* p2;
//对象的常引用
const super1& D(2);
类中静态函数与变量:
#include<iostream>
//无需对象即可调用
class super
{
public:
static int cont;
static int getcont(void)
{
return cont;
}
};
int super::cont=2;
int main()
{
std::cout<<super::getcont()<<std::endl;
return 0;
}
多继承:
class super
{
public:
int member;
super(int member)
{
this->member=member;
}
protected:
private:
};
class sub1:public super
{
public:
int member1;
sub1(int member,int member1):super(member)
{
this->member1=member1;
}
};
class sub2:public super
{
public:
int member2;
sub2(int member,int member2):super(member)
{
this->member2=member2;
}
};
class subsub:public sub1,public sub2
{
public:
subsub(int member,int member1,int member2):
sub1(member,member1),sub2(member,member2)
{
}
};
虚继承:
class super
{
public:
int member;
super(int member)
{
this->member=member;
}
protected:
private:
};
class sub1:virtual public super
{
public:
int member1;
sub1(int member,int member1):super(member)
{
this->member1=member1;
}
};
class sub2:virtual public super
{
public:
int member2;
sub2(int member,int member2):super(member)
{
this->member2=member2;
}
};
class subsub:public sub1,public sub2
{
public:
subsub(int member,int member1,int member2):
sub1(member,member1),sub2(member,member2),super(member)
{
}
};
虚函数:
#include<iostream>
//虚函数多态的条件:
//类之间的继承符合赋值兼容
//改写了同名虚函数
//根据赋值兼容规则使用指针或引用
//静态,内联,构造 函数不能是虚函数
class super
{
public:
virtual int operation(void)
{
return 1;
}
};
class sub:public super
{
public:
//不加virtual也是虚函数
int operation(void)
{
return 2;
}
};
void print(super *X,int(super::*Y)(void))
{
std::cout<<(X->*Y)()<<std::endl;
}
int main()
{
sub A;
super *B=&A,&C=A;
std::cout<<B->operation()<<std::endl;
std::cout<<C.operation()<<std::endl;
print(&A,&super::operation);
return 0;
}
重载运算符:
成员函数版:
class super
{
int member1,member2;
public:
super(int member1=0,int member2=0):
member1(member1),member2(member2) {}
super operator+(super &another);
//前置单目运算符重载:
super operator++();
//后置单目运算符重载:
super operator++(int);
super& operator+=(super& another);
//重载<<和>>(只能用友元函数)
friend std::ostream& operator<<(std::ostream& os,const super& other);
friend std::istream& operator>>(std::istream& is,super& other);
//重载强制转换运算符(不需指明返回值类型，默认和转换类型相同)
operator int();
void print(void)
{
std::cout<<member1<<","<<member2<<std::endl;
}
};
super super::operator+(super &another)
{
return super(member1+another.member1,member2+another.member2);
}
super super::operator++()
{
return super(++member1,++member2);
}
super super::operator++(int)
{
return super(member1++,member2++);
}
super& super::operator+=(super& another)
{
member1+=another.member1;
member2+=another.member2;
return *this;
}
std::ostream& operator<<(std::ostream& os,const super& other)
{
os<<other.member1<<","<<other.member2<<std::endl;
return os;
}
std::istream& operator>>(std::istream& is,super& other)
{
is>>other.member1>>other.member2;
return is;
}
super::operator int()
{
return member1+member2;
}
友元函数版:
class super
{
int member1,member2;
public:
super(int member1=0,int member2=0):
member1(member1),member2(member2){}
friend super operator+(const super& a,const super& b);
//前置单目运算符重载:
friend super operator++(super& a);
//后置单目运算符重载:
friend super operator++(super& a,int);
void print(void)
{
std::cout<<member1<<","<<member2<<std::endl;
}
};
super operator+(const super& a,const super& b)
{
return super(a.member1+b.member1,a.member2+b.member2);
}
super operator++(super& a)
{
return super(++a.member1,++a.member2);
}
super operator++(super& a,int)
{
return super(a.member1++,a.member2++);
}
模板:
//函数模板
template<typename T,typename U,typename V>
void fun(T param)
{
}
//类模板(带默认形参)
template<class T,class U,int V=2,class W=int>
class super
{
public:
T member;
super();
~super();
void operation(T val);
};
template<class T,class U,int V,class W>
super<T,U,V,W>::super()
{
}
template<class T,class U,int V,class W>
super<T,U,V,W>::~super()
{
}
template<class T,class U,int V,class W>
void super<T,U,V,W>::operation(T val)
{
}
定义方式:
super<int,int>A;
super<int,int,5>B;
super<int,int,5,int>C;
内联模板:
//函数模板
template<typename T,typename U,typename V>
inline void fun(T param)
{
}
//类模板
template<class T,class U,int V>
class super
{
public:
T member;
super(){}
~super(){}
void operation(T val)
{
}
};
模板的使用:
super<int,double,5>X;
命名空间:
//不能用于 函数,结构体,类内部
namespace A
{
int a;
}
namespace B
{
int a,b;
namespace C
{
int c,d;
namespace very_long_name_namespace
{
int e,f;
}
}
}
//可以没有名字
namespace
{
}
//简化名字
namespace D=B::C::very_long_name_namespace;
//可以不连续
namespace A
{
int b;
}
using std::cout;
using namespace std;
强制转换:
class super
{virtual void operation(void){}};
class sub:public super
{};
int main()
{
super *A,D;
sub B,*C;
//动态转换
//必须是指针类型的转换
A=dynamic_cast<super*>(&B);
//子类转换为基类
//基类必须有虚函数
C=dynamic_cast<sub*>(&D);
//静态转换
double fo0Old=2.33333333;
int fold=static_cast<int>(fo0Old);
return 0;
}
迭代器:
std::容器类<T>::iterator iter=容器对象.begin();
重载,覆盖,隐藏
重载:
相同的范围(在同一个类中)函数名字相同;
参数不同;
virtual关键字可有可无
覆盖:
不同的范围(分别位于派生类与基类);
函数名字相同
参数相同
基类函数必须有virtual关键字
隐藏:
如果派生类的函数与基类的函数同名,但是参数不同,不论有无virtual关键字,基类的函数将被隐藏
如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual 关键字,此时,基类的函数被隐藏
网友评论