首先我们要清楚什么是构造函数，每当我们创建一个类的对象时，系统会默认调用构造函数对我们所创建的对象进行赋值初始化操作，如果我们没有在类中定义构造函数，那么系统则会调用默认的构造函数进行初始化，且构造函数没有返还值，故也不存在返还值类型一说；

构造函数的语法如下：

类名（参数）{
初始化操作程序;
}

调用构造函数的语法如下：

类名变量名(参数);

那么，我们利用这一方法来重新创建对象：

#includeusingnamespacestd;

classPeople{
public:
//构造函数
People(intn,intm,stringx,inty){
      //将传入的参数依次赋值给成员变量
age=n;
weight=m;
name=x;
height=y;
}
//成员变量
stringname;
intheight;
voidpeople_display(){
cout<<"name:"<
对于该程序而言，我们自己定义了类中的构造函数，那么系统将不会调用默认构造函数，系统的默认构造函数是无参数构造类型的函数，也就是说其只负责在栈区开辟当前对象所需要的内存空间，不会进行赋值初始化等操作，而我们通过自己定义构造函数，从而完善了他的功能性
但是，假如现在我们要定义两个对象时，我们希望其中一个进行初始化，一个不进行初始化，那么我们按照之前的写法，如下所示：
intmain(){
  //Xiao_Ming进行初始化
PeopleXiao_Ming(18,60,"Xiao_Ming",180);
  //Xiao_Li不进行初始化
  PeopleXiao_Li;
}
此时编译器会对代码的第5行进行报错提醒：类People不存在默认构造函数，也就是所，系统找不到与之匹配的构造函数类型，因此想要完成目标，我们就需要利用c++中函数重载的特性；
(4)函数重载
什么是重载函数，在c++中我们可以定义多个名字相同的函数，但是其传输的参数的个数，类型，顺序不同，此时编译器会跟据调用该函数时，其所传入的参数的类型来判断具体调用哪个函数，函数重载具有以下几个特点：
c++允许在一个作用域中（一个{}中）的某个函数有多种定义；
在同一个作用域内可以声明几个功能类似的同名函数，但是这些同名函数的形参必须不同（顺序、类别、个数、const修饰）不可以仅仅通过返还值类型的不同来重载函数；
调用重载函数时，编译器通过把你所使用的参数类型与定义的参数进行比较，决定最合适的定义，该过程称作”重载决策“；
那么我们可以利用该特性，在类中定义多个构造函数，从而适应多种对象初始化的情况：
#includeusingnamespacestd;

classPeople{
public:
//构造函数1(有参数)
People(intn,intm,stringx,inty){
age=n;
weight=m;
name=x;
height=y;
//构造函数2(无参数)
}People(){
age=0;
weight=0;
name="尚未填写";
height=0;
}
//成员变量
stringname;
intheight;
voidpeople_display(){
cout<<"name:"<
在这段代码中，我们用两种的初始化方式，创建了对象Xiao_Ming和Xiao_Li；
注意：
这里我们在调用构造函数2也就是无参构造的时候，我们的写法是
PeopleXiao_Li;
而不是：
PeopleXiao_Li();
因为，我们如果写作第二种形式的话，编译器会认为我们是在做函数声明，声明了一个返还值类型为People类的函数，而不会将其认为是在调用无参的构造函数
(5)初始化参数列表
首先，我们要明白初始化和赋值的区别，初始化是在变量声明（分配好空间）的同时就为该变量所处的内区域的内存空间给予一个确定的值，而赋值则是清除空间的旧值并用新的值做拷贝替换，换而言之，赋值操作是初始化的一部分,如下代码所示：
intmain(){
  //对a进行初始化
  inta=1;
  //对b进行赋值
  intb;
  b=3
}
就实际意义，二者没有任何的区别，但是从代码运行的角度，赋值操作的本质是拷贝，也就是将已有的值从常量区复制拷贝到新的空间中去（具体可参考此文章：内存管理），因此，赋值相较于直接进行初始化而言会多进行一步复制拷贝的操作，故对于一些比较统一的成员变量我们可以考虑统一用初始化参数列表进行初始化，这样效率更高；
在使用初始化参数列表时注意：
只能在构造函数中使用初始化参数列表，可以给所有成员初始化；
成员的初始化顺序与类中的声明顺序一致，而与参数列表中的顺序无关；
const类型的变量和引用类型的变量必须在初始化参数列表中完成；
其中最后一条的原因：因为一旦我们创建了一个对象其内部的值如果未初始化就会被不确定的值所覆盖，构造函数中只能进行赋值操作，而无论是const类型的变量还是引用类型的变量都是不能进行赋值的，所以只能在初始化参数列表中进行初始化操作；
初始化参数列表的语法：
//构造函数
类名():成员变量1(给变量1初始化的值),成员变量2(给变量2初始化的值){
  构造函数内程序段;  
}
那么假设，我们现在要写一段程序，用来记录一个人信誉积分系统，起初每个人都是100分，每犯一次错误，就会减少1分：
#includeusingnamespacestd;
classpeople{
private:
stringname;
intscore;
public:
people(stringinput):score(100){
name=input;
}
voidmake_mistake(){
score--;
}
voidscore_display(){
cout<
对应这里的实际情况，因为每个人姓名都是不同的，因此我们将其以形参的形式传入到构造函数中，并传参到name中进行赋值，而由于每个人的初始分数都是100，故放在初始化参数列表中进行直接初始化，从而高效的实现了这一程序；
3、析构函数
和构造函数的功能相对应，构造函数用于初始化类的对象，而析构函数则是用于清理释放掉生命周期已经结束的对象(对象声明处所在的{}内为其整个生命周期)；
与构造函数相同的是，如果我们未在类中定义析构函数，那么在某一个对象的生命周结束时，系统会自动调用默认的析构函数释放其所占用的内存空间，但是系统只能自动清理栈区空间，如果我们在构造函数中对我们的对象进行初始化的时候使用new或malloc这类函数向堆区申请了额外空间的话，需要手动用delet或free来释放这部分的空间，因此，需要自己在类中定义析构函数，从而完成其功能；
对于析构函数，其语法为：
~类名(){
  析构函数内程序段;
}
那么我们来看以下的程序：
#include#includeusingnamespacestd;
classpeople{
public:
people(constchar*xh,constchar*dh){

std_id=newchar[32];
strcpy(std_id,xh);

tel=newchar[32];
strcpy(tel,dh);
}
~people(){
delete[]std_id;
delete[]tel;
}
voidinf_display(){
cout<<"std_id:"<
4、静态成员
 (1)静态成员变量
我们用关键字“static”修饰一个类中的成员变量时，我们称该变量是静态成员变量，通过普通的静态变量的特点我们可以知道，静态变量储存在全局区，生命周期是从程序开始到程序结束，也就是说对于同一个类的多个对象而言，其静态成员是公用的，并不会随对象的创建而分配内存，也不会随某一个对象释放时而释放内存；
静态变量初始化的时候可以赋初值，也可以不赋初值，其默认为0，但是如果对其赋值应该在类外进行初始化！
那么利用这一特点，我们可以利用静态成员变量来记录我们所创建的对象的个数，如下代码所示：
#includeusingnamespacestd;
classpeople{
public:
staticintnum_people;
people(){
num_people++;
}
people(stringname,intage){
num_people++;
}
    ~people(){
      num_people--;
    {
};
//静态成员变量初始化
intpeople::num_people=0;
intmain(){
peopleXiao_Ming();
peopleXiao_Li("Xiao_Li",18);
cout<
也就是每当我们的程序调用了构造函数时，说明该增加了一个该类的对象，就会对num_people加1，而每当程序调用了析构函数时，说明有一个对象被释放了，从而num_people减1；
而且这段程序中值得我们注意的是：我们在主函数的结尾，输出当前对象个数的时候，我们使用的是“：：”而不是“.”，这就说明静态成员变量不属于某个对象，而是属于整个类的；
因此，对于静态成员变量需要注意的是：
静态成员变量属于整个类所有，所有对象共享其所属类的静态成员变量；
静态成员变量的初始化应该在类外进行；
可以通过类名直接访问公有（public）静态成员变量；
可以通过对象名直接访问公有（public）静态成员变量；
静态成员变量在程序内部位于全局区（静态区）；
静态成员变量的生命周期不依赖于任何的对象，与程序的生命周期一致；
(2)静态成员函数（this指针）
用staitic来修饰类中的成员函数，该函数便称为静态成员函数，与静态成员变量一致，静态成员函数也是归类所属，而非是某一个对象；
对静态成员函数最重要的特点是其只能访问静态成员变量或其他的静态成员函数，原因在于其内部没有“this”指针；
“this”指针也被称作是"自引用指针"，每当创建了一个对象的时候，系统会自动将this初始化指向当前对象，而当调用成员函数时，”this“也会作为一个隐含参数传入到函数中；
由于我们的程序时逐条执行的，因此就不存在这同时对多个对象进行操作的可能，那么在一段程序中，可能存在着多个同类的对象，当程序执行到某个位置的时候，想要知道当前正在操作的具体是哪个对象，就需要由this指针做指引，也就是说this指针所指向的就是当前正在被调用的对象，例如以下代码：
#includeusingnamespacestd;
classpeople{
  public:
    intage;
    stringname;
    intweight;
    voideat(){
       weight++; 
    }  
};
intmain(){
  peopleXiao_Ming;
  Xiao_Ming.eat();
}
首先我们创建了一个对象“Xiao_Ming”当我们调用其内部的成员函数eat()时，此时this指针指向了对象“Xiao_Ming”，此时，”this“作为隐含参数传入到eat( )当中，我们虽然写作“weight++”而实际所执行的是“this->weight++”或者是“Xiao_Ming.weight++”而对于静态成员变量或静态成员函数而言，其不属于任何一个对象，故其类型与this指针的类型不匹配，自然无法进行指向，故无法通过静态成员函数来访问非静态成员变量或函数（无this指针指向）
但是，静态成员函数的好处在于，可以将其视为一个全局的函数，我们可以通过类名对其访问，而不需要先创建一个对象再通过对象进行访问，如下所示：
#includeusingnamespacestd;
classpeople{
public:
    staticintnum_people;
    staticvoidshow_num{
      cout<
5、友元
 (1)友元的概念
我们知道，类中的成员变量或成员函数可以被我们用不同的访问修饰符进行修饰的，其包括public、private、protected三种，其中public是共有的，任何对象或函数都可以对其进行访问，但是对于private和protected：
private：只能由类内成员函数、友元访问；
protected：只能由类内成员函数、子类函数、友元访问；
因此，友元的作用就是帮助类外其他函数或其他类，来访问类内私有或受保护的成员变量或函数；
友元的关键字：friend
(2)类外的全局函数作为类的友元
如果我们希望类A外的函数a可以访问友元中的私有(受保护)成员，那么我们应该在类A中声明，a函数是类A的友元，代码如下：
#includeusing namespace std;
class A {
    public:
        int a;
    private :
        int b;
    // 友元函数的声明
    friend void fun();
};
//友元函数的类外实现
void fun() {
    A s;
    s.a = 1;
    // 在全局函数fun()中访问了类A中对象s的私有成员变量b
    s.b = 2;
    cout<< s.a + s.b<< endl;
}
在这段程序中，我们可以看到在类A中，a是公共的，b是私有的，但是由于我们在类A中声明了，fun( )是类A的友元函数，因此即使fun是类外的函数，却依旧可以通过创建对象来访问b
(3)类A作为类B的友元
如果我们希望，类B的任意成员函数可以访问类A对象的私有成员，那么我们应该声明，类B是类A的友元，如下代码所示：
#includeusing namespace std;
class A {
    public:
        int a;
    private :
        int b;
    // 友元函数的声明
    friend class B;
};
class B {
    public:
        void fun() {
            A s;
            s.a = 1;
            //在B的成员函数fun中访问了类A中对象s的私有成员b    
            s.b = 2;
            cout<< s.a + s.b<< endl;
        }
        void fun1() {
            A s;
            s.a = 1;
            //在B的成员函数fun1中访问了类A中对象s的私有成员b 
            s.b = 2;
            cout<< s.a * s.b<< endl;
        }
};
在这段程序中，我们将类B做为类A的友元，可以看到此时类B的任意成员函数均可以访问类A对像的私有成员变量
(4)类B中的成员函数作为类A的友元
假如，我们只希望类B中特定的成员函数可以去访问类A的私有成员变量，那么我就不能将整个类B作为类A的友元，而是把特定的成员函数作为友元来声明，如下代码所示：
#includeusing namespace std;
class B {
    public:
        void fun();
};

class A {
    public:
        int a;
    private:
        int b;
        friend void B::fun();
};
void B::fun() {
    A s;
    s.a = 1;
    s.b = 2;
    cout<< s.a + s.b<< endl;
}
在这段代码的写法上，有两点值得我们注意：
我们将类A的定义写在了类B的下面，如果我们写作了下述代码形式的话，由于编译器是顺序编译，因此fun( )函数的声明应该写在friend关键字声明之前，否则会出现编译器先看到了友元的声明却找不到函数的情况；
#includeusing namespace std;
class A {
    public:
        int a;
    private:
        int b;
        friend void B::fun();
};
class B {
    public:
        void fun();
};
void B::fun() {
    A s;
    s.a = 1;
    s.b = 2;
    cout<< s.a + s.b<< endl;
}
其次，我们将fun( )函数的定义写在了类外而不是和声明写在一起，其原因与第一条类似，如果我们将
代码写作 如下形式的话，会出现编译器编译fun( )的时候，尚不知道fun( )是类A的友元，从而让fun( )依旧无法访问类A的私有成员变量；
#includeusing namespace std;
class B {
    public:
        void fun(){
            A s;
            s.a = 1;
            s.b = 2;
            cout<< s.a + s.b<< endl;
        }
};
class A {
    public:
        int a;
    private:
        int b;
        friend void B::fun();
};
6、常成员变量和函数
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
                    

                    当前名称：CPP笔记——“类和对象”-创新互联                    

                    新闻来源：http://chengdu.cdxwcx.cn/article/ccspgd.html