c++⾯向对象程序设计总结（类的使⽤）本篇算是学习c++有关类的知识的⼀些易错点吧.....
并不是特别详细，以后会更新吧....
⼏点并不关于类的东西
1.函数模板，⽤虚拟类型来实现模板的功能
#include<iostream>
using namespace std;
template <typename t>//t为虚拟类型的名字，⾃⼰起的
t maxx(t a,t b,t c)
{
return max(a,max(b,c));
}
int main()
{
double a=1.1,b=2.2,c=3.3;//不管为double 还是int都可以调⽤maxx
cout<<maxx(a,b,c)<<endl;
int a1=1,b1=2,c1=3;
cout<<maxx(a1,b1,c1)<<endl;
}
2.关于函数默认的参数值要放到最右边
void f1(float a,int b=0,int c,char d='a');//错误，
void f2(float a,int c,int b=0,char d='a');//正确
3.内置函数
函数最左边加上inline(我觉得没啥⽤)，规模很⼩的函数才⽤
4.字符串
sizeof(string) 为4，因为系统分配的是固定的字节数，存放的是字符串的地址
.......（以后再补充把）
开始类的学习
1.三种类的类型
public
这个就不多说了，类的对外接⼝
private
想要访问只能通过该类中的函数来访问
protected
和private差不多，区别在于继承时，以后说
2.类的声明和成员函数的分离（以后更新）
3.构造函数
没有返回值，名字和类名字⼀样#include<iostream>
using namespace std;
class box{
public:
box(int ,int ,int );//构造函数（有⽆默认参数都⾏）
int volume();
private:
int h;
int w;
int l;
};
box::box(int a,int b,int c)
{
h=a,w=b,l=c;
}
//其实⼀般这样写
// box::box(int a,int b,int c):h(a),w(b),l(c){}
//注意如果是数组的话则要写在⼤括号内
//box::box(int a,int b,int c,char nam[]):h(a),w(b),l(c)
/
/{strcpy(name,nam);}
可以⽤另⼀个对象初始化另⼀个
time t1;
time t2=t1;  //注意是吧t1的数据成员复制到t2，⽽不调⽤t2的构造函数
4.析构函数
注意⼀点，先构造的后析构，相当于栈，先进后出
静态局部对象，在函数结束时，并不释放，也就不调⽤析构函数
5.对象数组
box b[3] = (1 , 2 ,3)//这样其实不对，这三个实参则分别作为3个元素的第⼀个实参初始化应该
box a[3]={
box(10,20,30);
box(20,30,40);
box(1,2,3);
}
6.对象指针
先说下函数指针。。。。还有函数指针？？？？
类型名（* 指针变量名）（参数列表）
void (* p)();//p是⼀个指向void型函数的指针
p=fun;//fun函数⼊⼝地址付给p 注意没有括号
(*p)();
对象成员函数有些复杂
要求函数参数类型和个数匹配函数返回值类型⼀样所属的类⼀样void ( time:: *p )();//此时p为指向time类中的成员函数指针
time t;
void (time:: *p)();
指针调用成员函数
p = &time::gettime();
(t.*p)();
7.this指针（指向当前对象）
当前被调⽤的成员函数所在对象的起始地址
int box::volume()
{return (h*l*w);}//实际为{ return this->h * this->l * this->w;}
调⽤时如 a.volume() ，实际为将对象a的地址传给形参this指针
8.常对象
只能通过构造函数参数表来对其初始化，所有数据成员绝对不能被改变，并且只能调⽤它的常成员函数如果⾮要改变，要加上 mutable 如有⼀个计数变量count，则要 mutable int count;
⾮const数据成员⾮const函数可引⽤和改变 const函数可引⽤不可改变
const数据成员⾮const函数可引⽤不可改变 const函数可引⽤不可改变
const函数不可调⽤⾮const函数
常指针如
Time t1;
Time * const p = =&t1;
p不可再改变
常变量只能被常指针指向，，
普通变量也可被常指针指向，但这时该普通变量就在这期间变成的常变量，不能改变
复制构造函数
Box box2(box);
9.静态数据成员
数据声明前加 static
特点是可以被每个该同类对象所引⽤，只能在类体外进⾏初始化，在类外也可直接引⽤
如 int Box::height = 10;//不必加static
可以通过对象名来引⽤，也可以通过类名
如
cout<&unt<<endl;
cout<<Box::count<<endl;
10.友元
友元函数可以使⼀般的，也可以是另⼀个类中的，可以访问私有数据成员
友元类就是全家都是友元函数
注意是单向的，注意不能传递
11.类的模板
temple<class t>//t 为虚拟变量名字可以有多个，但都要加class 如：temple<class t1,class t2> class compare{
public:
compare(t a,t b)
{
x=a,y=b;
}
t max() {
return max(a,b);
}
private:
t x,y;
};
定义对象时为：
compare<int> cmp(3,4);
//多个时 compare<int ,double> cmp(3,4);
12.对运算符的重载
class yuan{
public:
yuan(double a,double b):x(a),y(b){};
yuan operator +(yuan &t)
{
return yuan(x+t.x, y+t.y);
}
private:
double x,y;
};
此时如果有
yuan c1(1,2),c2(1,2),c3;
c3 = c1 + c2;
则实际为 c3 = c1.operator(c2);
但其实我觉得更⽅便的是通过友元函数
class yuan{
public:
yuan(double a,double b):x(a),y(b){};
friend yuan operator +(yuan &t1,yuan &t2)//这个其实挺灵活的，可以⾃⾏改变        {
return yuan(t1.x+t2.x, t1.y+t2.y);
}
private:
double x,y;
};
c3 = c1 + c2 则解释为operator +(c1,c2);
13.继承
派⽣类拥有基类的数据成员，其分配如下
先说公有继承
基类属性派⽣类
private                                  不可访问
public          公有继承后        public
protected                            protected
私有继承
基类属性派⽣类
private                                  不可访问
public          私有继承后        private
protected                            private
保护继承
保护成员：只有⼦⼥（派⽣类）可以访问，（友元函数也不⾏）
基类属性派⽣类
private                                  不可访问
public          保护继承后        protected
protected                            protected
14.有⼦对象的派⽣构造函数
#include<iostream>
using namespace std;
class Student{
public:
void display();
Student(int n,string nam):num(n),name(nam){}
protected:
int num;
string name;
};
class Student1: public Student{
public:
Student1(int n,string nam,int n1,string nam1,int a,string ad):
Student(n,nam),monitor(n1,nam1),age(a),addr(ad){}//注意初始化，⼀般⽤初始化表来，同样的，在多级派⽣中也是如此来构造void show()
{
monitor.display();
}
protected:
Student monitor;//派⽣类中的⼦对象
int age;
string addr;
};
int main()
{
}
多级的形式
派⽣类构造名: 基类1构造函数(参数表) , 基类2构造函数(参数表) , 基类3构造函数(参数表)
{  派⽣类中新增的数据成员初始化语句 }
15 . 关于多重继承的⼆义性问题
就是继承的函数名和派⽣的函数名⼀样了
假设有类A和类B，此时类C同时继承类A和类B，现在问题是类A 类B  类C都有⼀个叫display()的函数
C c1;
c1.display()//此时该是谁呢，是最新的也就是c的display（）。这个会覆盖
此时要想访问A的display（），则要限定作⽤域。
⽐如  c.A::display();
16.虚基类
D 是 B 和 C 的派⽣类，B 和 C ⼜都是继承了A，这样会保留多份数据成员的拷贝
虚基类是的在继承简介共同基类时只保留⼀份

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。