学习笔记 C++ 类与对象

zoukankan html css js c++ java

学习笔记 C++ 类与对象
类与对象

学了之后感觉类与结构体其实差不太多

1.声明类
```
class Human
{
	string Name;//内部变量
	int Age,Birth;
	
	void Talk(string Text);//封装函数
	void IntroduceSelf();
};
```
注：属于类的函数被称为方法

2.实例化对象

就像结构体一样运行程序时使用类的话也需要实例化
```
class Human
{
    //...
};

Human person;
```
3.访问类的成员

访问类的成员也类似于结构体存在句点访问和指针运算符(->)访问
```
class Human
{
    public:
      string Name;
      int Age,Birth;
	
      void Talk(string Text);
      void IntroduceSelf();
};
Human person;
Human* people;

int main()
{
    cout<<person.Age<<endl;
    people->Talk("string");
    return 0;
}
```
4.关键字private和public

定义类的时候有的时候会这么定义
```
class Human
{
    private:
        string Name;//内部变量
        int Age,Birth;
    public:
        void Talk(string Text);//封装函数
        void IntroduceSelf();
};
```
诚如字面意思

private下面定义的变量和函数只能在类内部调用

public下面定义的变量和函数可以在外部调用

就像这样

这样的优点是：可以通过合适的方法暴露内部变量从而防止外部输入对内部设置造成破坏

这也体现了C++作为面向对象的程序设计语言的特点：C++让类的设计者能够控制类属性的访问与操作方式

5.关键字private实现数据抽象

有的时候类内部的数据不能直接公开

所以类内部使用private定义数据加以抽象化输出 实际上就是外部无法直接访问合法的访问又经过了内部加工
```
class Human
{
    private:
      string Name;//内部变量
      int Age,Birth;
    public:
      int GetAge()
      {
	if(Age>30) cout<<Age-2<<endl;//唯一的合法访问经过了内部加工
	else cout<<Age<<endl;
      }  
};
```
6.构造函数

构造函数是一种特殊的函数 ta与类同名且不返回任何值

内部声明如下:
```
class Human
{
    public:
      Human()
      {
          //... 
      }
};
```
外部声明如下：
```
class Human
{
    public:
      Human();
};
Human::Human()
{

}
```
构造函数总是在创建对象的时候调用 是类成员变量初始化为已知值的理想场所

比如说：
```
class Human
{
    private:
      string Name;
      int Age;
    public:
      Human()
      {
        Name="WangXiaoMing";
      	Age=20;
      }
};
```
同样构造函数支持重载可创建一个默认构造函数和多个包含不同形参的重载构造函数
```
#include<bits/stdc++.h>
using namespace std;
class Human
{
    private:
      string Name;
      int Age;
    public:
      Human()
      {
      	Name="WangXiaoMing";
      	Age=20;
      }
      Human(string InputName)
      {
	Name=InputName;
	Age=38;
      }
	Human(string InputName,int InputAge)
      {
	Name=InputName;
        Age=InputAge;
      }
      void IntroduceSelf()
      {
        cout<<Name<<" "<<Age<<endl;
      }
};

int main()
{
  Human cdy;
  Human wzy("GaoXiaoHong");
  Human zjz("YuXiaoLiang",17);
  cdy.IntroduceSelf();wzy.IntroduceSelf();zjz.IntroduceSelf();
  return 0;
}

//
Output:
WangXiaoMing 20
GaoXiaoHong 38
YuXiaoLiang 17
//
```
注意如果一个函数只存在重载的构造函数而不存在默认的构造函数的话

如果我们还直接Human cdy;这样直接声明类的话是不合法的

必须要提供内部变量的默认值

可以在声明的时候提供 Human zjz("YuXiaoLiang",17);

也可以在定义构造函数的时候添加默认值
```
class Human
{
    private:
      string Name;
      int Age;
    public:
      Human(string InputName="Adam",int InputAge=20)//添加默认值
      {
	Name=InputName;
        Age=InputAge;
      }
      void IntroduceSelf()
      {
        cout<<Name<<" "<<Age<<endl;
      }
};

Human cdy;
Human zjz("YuXiaoLiang",17);
//这样声明都是合法的
```
我们籍此也能明白 默认构造函数是调用时可不提供参数的构造函数，不意味ta不接受任何参数

同时还存在一种写法就是初始化列表
```
class Human
{
    private:
      string Name;
      int Age;
    public:
      Human(string InputName="Adam",int InputAge=20):Name(InputName),Age(InputAge){}
      void IntroduceSelf()
      {
        cout<<Name<<" "<<Age<<endl;
      }
};

Human cdy;
Human zjz("YuXiaoLiang",17);
//这样声明都是合法的
```
7.析构函数

与构造函数一样析构函数也是一个看起来与类同名的函数但是前面有一个波浪号~
```
class Human
{
  ~Human();
};
```
析构函数同构造函数类似既可以在类内部声明也可以在类外部声明

析构函数的作用与构造函数完全相反

每当对象不再在作用域内或者通过delete删除继而被销毁时都将调用析构函数

析构函数是重置变量以及释放动态内存和其他资源的理想场所

我们使用C风格char* s;的字符串时必须自己管理内存分配因此建议使用std::string等工具

后者都是类而且充分利用了构造函数和析构函数

接下来演示一下如何在构造函数中为一个字符串分配内存并在析构函数中释放
```
#include<bits/stdc++.h>
using namespace std;
class MyString
{
  private:
    char* buffer;
  public:
    MyString(const char* InitialString)
    {
      if(InitialString!=NULL)
      {
        buffer=new char[strlen(InitialString)+1];
        strcpy(buffer,InitialString);	
      }
      else buffer=NULL;	
    }	
    ~MyString()
    {//析构函数
      printf("Now we delete.\n");	
      if(buffer!=NULL) delete[] buffer;	
    }
    int getlen(){return strlen(buffer);}
    const char* getstring(){return buffer;}
};
int main()
{
  MyString person("Say Hello To The World");
  printf("It has %d characters.\n",person.getlen());
  printf("buffer contains:%s.\n",person.getstring());
  return 0;
} 
//
Output:
It has 22 characters.
buffer contains:Say Hello To The World.
Now we delete.
//
```
8.复制构造函数

我们调用函数的时候double Area(double InputRadius)实参会被复制给形参InputRadius 这种规则也适用于对象

上一程序当中 MyString类包含了一个指针类型成员指向动态分配的内存

复制这个类的时候我们会复制指针 但是不会复制指针指向的缓冲区也就是导致两个对象指向同一块动态分配的内存

我们称之为浅复制 这会威胁程序的稳定性

比如说下面这个程序
```
#include<bits/stdc++.h>
using namespace std;
class MyString
{
  private:
    char* buffer;
  public:
    MyString(const char* InitialString)
    {
      if(InitialString!=NULL)
      {
      buffer=new char[strlen(InitialString)+1];
      strcpy(buffer,InitialString);	
      }
      else buffer=NULL;	
    }	
    ~MyString()
    {
      printf("Now we delete.\n");	
      if(buffer!=NULL) delete[] buffer;	
    }
    int getlen(){return strlen(buffer);}
    const char* getstring(){return buffer;}
};
void UseMyString(MyString person)
{
  printf("It has %d characters.\n",person.getlen());
  printf("buffer contains:%s.\n",person.getstring());
  return;
}
int main()
{	
  MyString person("Say Hello To The World");
  UseMyString(person);
  return 0;
} 
```
运行结果如下:

如果你可以看懂Dev-C++的exe的话没错RE(runtime error)了

C++中使用delete释放内存块或者指针内存之后不要进行访问不能多次释放

由于形参复制实参之后指针指向的是同一内存所以void UseMyString(MyString person)在运行结束之后析构函数调用delete释放了这块内存而主函数运行结束之后析构函数对于同一块内存又释放了一次所以导致RE

一般来讲编译器会默认进行深复制
但是这里没有因为编译时ta不确定MyString::buffer指向的是多少字节的内存

所以我们使用复制构造函数进行深复制

复制构造函数也存在内部声明与外部声明

大概长成这个模样
```
class MyString
{
  MyString(const MyString& CopySource)
  {	
  }
};
MyString::MyString(const MyString& CopySource)
{
}
```
具体如下：
```
#include<bits/stdc++.h>
using namespace std;
class MyString
{
  private:
    char* buffer;
  public:
  MyString(const char* InitialString)
  {
    if(InitialString!=NULL)
    {
      buffer=new char[strlen(InitialString)+1];
      strcpy(buffer,InitialString);	
      cout<<"buffer points to 0x"<<hex<<(unsigned int*)buffer<<endl;
    }
    else buffer=NULL;
  }	
  MyString(const MyString& CopySource)
  {//复制构造函数
    printf("Now we are copying\n");
    if(CopySource.buffer!=NULL)
    {
      buffer=new char[strlen(CopySource.buffer)+1];
      strcpy(buffer,CopySource.buffer);	
      cout<<"buffer points to 0x"<<hex<<(unsigned int*)buffer<<endl;
    }
    else buffer=NULL;
  }
  ~MyString()
  {
    printf("Now we delete.\n");	
    if(buffer!=NULL) delete[] buffer;	
  }
  int getlen(){return strlen(buffer);}
  const char* getstring(){return buffer;}
};
void UseMyString(MyString person)
{
  printf("It has %d characters.\n",person.getlen());
  printf("buffer contains:%s.\n",person.getstring());
  return;
}
int main()
{	
  MyString person("Say Hello To The World");
  UseMyString(person);
  return 0;
} 
```
复制构造函数可以保证函数调用的时候神采用深复制

但是当通过复制进行复制时由于我们没有指定任何赋值运算符 赋值仍然采用浅复制 所以我们还需要制定赋值运算符
```
MyString::operator =(const MyString& CopySource){}
```
复制构造函数调用形参时添加const可防止源对象被修改同时复制构造函数的参数必须按引用传递否则调用时将复制形参的值导致浅复制——这正是我们要极力避免的

所以 类包含原始指针成员(char*等)时，务必编写复制构造函数和复制复制运算符

为了减少工作量务必将类成员声明为std::string和智能指针类，而非原始指针，因为它们自己实现了复制构造函数

9.结构不同于类的地方

关键字struct来自于C 在C++来看与类及其相似差别在于程序员未指定时默认的访问限定符(private与public)不同

除非指定了否则结构中的成员默认为公有的

除非指定了否则结构以公有方式继承基结构

10.声明友元

对于类中private定义的私有数据成员和方法我们无法从外部访问但是这不适用于友元类和友元函数

我们通过关键字friend声明友元从而使得友元类和友元函数可以访问私有数据成员和方法
```
#include<bits/stdc++.h>
using namespace std;
class Human
{
  private:
  string Name;
  friend class Unity;//声明友元类
  friend void Display(const Human& person);//声明友元函数
  public:
  Human(string InputName="Adam"):Name(InputName){}
};
class Unity
{
  public:
  static void DisplayAge(const Human& person)
  {cout<<person.Name<<endl;}
};
void Display(const Human& person)
{
  cout<<person.Name<<endl;
}
int main()
{	
  Human cdy;
  Display(cdy);
  Unity::DisplayAge(cdy);
  return 0;
} 
```
11.静态数据类型

类的数据成员和函数成员可以分为两类静态与非静态

通过在类型名之前添加static 可以使静态成为非静态

类的静态成员(变量和方法)属于类本身，在类加载的时候就会分配内存，可以通过类名直接去访问；非静态成员（变量和方法）属于类的对象，所以只有在类的对象产生（创建类的实例）时才会分配内存，然后通过类的对象（实例）去访问。

非静态成员需要在类实例化之后才能使用而静态成员既可以通过实例化使用也可以不经过实例化使用

也就是 静态成员与类相联系不与类的对象相联系
```
class Student
{
  public:
    static int allcoount;
    int cardnumber;
};
int main()
{
  Student s1;
  Student::allcoount;//未经实例化便可以使用
  s1.allcoount;//经过实例化也可以使用 
  s1.cardnumber;//只有经过实例化才可以使用 
  return 0;
} 
```
静态成员数据

使用的时候必须要初始化 并且是在类中声明在类外初始化
【为什么static数据成员一定要在类外初始化?】
```
#include<bits/stdc++.h>
using namespace std;
class Student
{
  public:
    static int allcoount;
};
int Student::allcoount=0;
int main()
{
  for(int i=1;i<=10;++i) Student::allcoount++;
  printf("%d\n",Student::allcoount);
  return 0;
}  
```
在实际运行的时候静态成员数据为所有类共享 ta可以被所有的类对象修改也可以被所有的类对象访问
```
#include<bits/stdc++.h>
using namespace std;
class Student
{
  public:
    static int allcount;
  Student(){allcount++;}
};
int Student::allcount=0;
int main()
{
  for(int i=1;i<=10;++i)
  {
    Student* now=new Student;
    cout<<now->allcount<<endl;	
  }
  cout<<Student::allcount; 
  return 0;
} 
/*
Output:
1
2
3
4
5
6
7
8
9
10
10
*/
```
静态成员函数

使用类似于静态成员数据既可以实例化也可以不实例化
```
#include<bits/stdc++.h>
using namespace std;
class Student
{
  public:
    static void print(){printf("Hello Word!\n");}
};
int main()
{
  Student s;
  Student::print();
  s.print();
  return 0;
} 
```
上文我们已经说过了静态成员在非静态成员之前已经与全局变量一起被分配内存

故一个静态成员函数不与任何对象相联系不能对非静态成员进行默认访问
```
#include<bits/stdc++.h>
using namespace std;
class Student
{
  private:
    string name;
  public:
    Student()
    {name="ewkjhkjsd";}
    static string findname()
    {return name;}//这是错误的 因为不知道这里的name隶属于哪个对象？
};
int main()
{
  Student ss;
  cout<<ss.findname()<<endl;
  return 0;
} 
```
若要访问非静态成员时，必须通过参数传递的方式得到相应的对象，再通过对象来访问

Q:静态成员函数与非静态成员函数的根本区别是什么？

A:根本区别在于静态成员函数没有this指针而非静态成员函数有一个指向当前对象的this指针

一般来讲非静态成员函数会将当前的对象的地址作为第一个传递参数 传递的形参就是 this指针

在函数内部非静态成员函数在访问非静态成员时都会自动将this参数作为指向当前对象的指针

而静态成员函数被调用没有任何对象的地址被传递

因此当访问非静态成员时无this指针会出错

这也是为什么一个静态成员函数会与当前任何对象都无联系

12.继承

1).含义

类中的一些东西我觉得很好希望其它类中也有这样就有了继承这个概念

继承顾名思义 就是一个类从另一个类中继承了部分数据成员和方法 继承的那个类叫做派生类 被继承的类叫做基类
```
class A //基类
{};
class B:public A  //派生类
{};
```
2).派生类对于基类的调用

派生类可以直接使用基类中定义的部分数据成员和方法

但是要注意的是由于构造函数和析构函数不是虚函数所以基类的构造函数和派生函数无法被派生类继承

同时具体的调用的话和派生类的继承方式以及基类中定义的成员和方法的类型有关

首先类中定义的数据成员和方法有三种类型: private,protected,public~~三p党~~

private:只有在类中函数以及友元函数可以调用

protected:只有在类中函数，友元函数以及继承的派生类中函数可以调用

public:可以在任意情况下调用

而继承方式也有三种 私有继承(private),公有继承(public),保护继承(protected)
```
class A
{};
class B:public A //公有继承
{};
class C:private A //私有继承
{};
class D:protected A //保护继承
{};
```
而在派生类中访问基类成员的权限则是继承方式与基类成员类型共同作用的结果

1.公有继承 public
①基类中为public 派生类中仍为protected
②基类中为protected 派生类中仍为protected
③基类中为private 派生类中无法访问

2.保护继承 protected
①基类中为public 派生类中为protected
②基类中为protected 派生类中仍为protected
③基类中为private 派生类中无法访问

3.私有继承 private
①基类中为public 派生类中为private
②基类中为protected 派生类中为private
③基类中为private 派生类中无法访问

源自我的课本

保护继承和私有继承这种代码重用方式更多地考虑到代码安全初学者很少涉及
①公共继承，将使基类作为开源代码不断让类程序员派生代码从而迅速传播
②保护继承，将使基类作为公司的内部技术不断接续和派生
③私有继承，将使技术世代单传，开发者在其派生类中也只能通过调用基类的方法来访问基类

3).派生类的构造函数与析构函数

【借鉴的博客】

构造函数

派生类无法继承基类的构造函数所以只能在派生类中自定义构造函数而如果要初始化基类的数据成员必须调用基类的构造函数

接下来是简单的调用
```
#include<bits/stdc++.h>
using namespace std;
class cdy
{
  protected:
    int a,b;
  public:
    cdy(int aa,int bb):a(aa),b(bb){}	
    void print(){printf("a=%d b=%d\n",a,b);}
};
class wzy:public cdy
{
  protected:
    int c;
  public:
    wzy(int aa,int bb,int cc):cdy(aa,bb),c(cc){}
    void print(){printf("a=%d b=%d c=%d\n",a,b,c);}
};
class zjz:public wzy
{
  protected:
    int d,e;
  public:
    zjz(int aa,int bb,int cc,int dd,int ee):wzy(aa,bb,cc),d(dd),e(ee){}
    void print(){printf("a=%d b=%d c=%d d=%d e=%d\n",a,b,c,d,e);}	
};
int main()
{
  cdy x(100,140);
  wzy y(100,250,38);
  zjz z(238,23,4,75,123);
  x.print();
  y.print();
  z.print();
  return 0;
}
```
调用结果如下:

如果派生类中包含了基类子对象作为其成员
```
#include<bits/stdc++.h>
using namespace std;
class cdy
{
  protected:
    int a,b;
  public:
    cdy(int aa,int bb):a(aa),b(bb){}	
    int needa(){return a;}
    int needb(){return b;}
    void print(){printf("a=%d b=%d\n",a,b);}
};
class wzy:public cdy
{
  protected:
    int c;
    cdy d;
  public:
    wzy(int aa,int bb,int cc,int dd,int ee):cdy(aa,bb),c(cc),d(dd,ee){}
    void print(){printf("a=%d b=%d c=%d d.a=%d d.b=%d\n",a,b,c,d.needa(),d.needb());}
};
int main()
{
  cdy x(100,140);
  wzy y(238,23,4,75,123);
  x.print();
  y.print();
  return 0;
}
```
这是调用结果

要注意的是

①
在调用派生类构造函数之前系统会先调用基类的构造函数
如果派生类构造函数中含有对基类子对象的初始化那么基类子对象也会先调用自己的构造函数来初始化自身
最后才是派生类调用自己的构造函数来初始化自身新增成员

②
如果基类无构造函数或者基类构造函数无参(无法传递参数)
那么会调用基类默认的构造函数来初始化

③
基类中重载了构造函数则对于基类成员初始化时构造函数具体调用会视参数使用个数的状况而定

析构函数

这里的话我没有整理太多

只需要明白 关于继承构造函数先实现调用基类构造函数再调用派生类构造函数而析构函数则先实现调用派生类析构函数再调用基类析构函数

4)派生类对于访问控制的调整

在派生类中可以调整成员的访问控制属性类如将基类的公有成员调整为私有成员保护成员调整成公有成员 .etc
```
class Base
{
  private:
    int b1;
  protected:
    int b2;
    void fb2(){b1=1;}
  public:
    int b3;
    void fb3(){b1=1;}	
};
class Pri:private Base//私有继承导致基类全部成员为私有或者不可见 
{
  public:
    using Base::b3;//调整基类成员b3为公有 

};
int main()
{
  Pri pri;
  pri.b3=1;// ok
}
```
前提：调整对象必须是在派生类中课件例如例子代码基类中的b1作为基类私有成员在派生类中不可见无法进行调整

5)多继承

有的类可以作为多个基类的派生类
```
class Base1
{
  protected:
    int id;
  public:
    Base1():id(0){}
    void Base1print(){printf("now is Base1.\n");}
    void changeid(int x){id=x;}
};
class Base2
{
  protected:
    int id;
  public:
    Base2():id(0){}
    void Base2print(){printf("now is Base2.\n");}
    void changeid(int x){id=x;}	
};
class Pri:public Base1,public Base2//私有继承导致基类全部成员为私有或者不可见 
{
  public:
    Pri(){};
    void Priprint(){printf("now is Pri.\n");}
};
int main()
{
  Pri pri;
  pri.Base1print();
  pri.Base2print();
  pri.Priprint();

  return 0;
}
```
输出结果:
```
now is Base1.
now is Base2.
now is Pri
```
然而我们发现 当两个基类中出现相同的成员时(例如例子代码中的id) 会导致直接访问时冲突

这就是多继承的模糊性

我们必须要说明基类否则会编译错误
```
pri.Base1::changeid(2);
pri.Base2::changeid(3); 
```
6)虚拟继承

按上述的例子我们可以发现其实我们可以将这些基类的共同属性再汇总到一个类中去
```
class Base
{
  protected:
    int id;
  public:
  	
    Base():id(0){}
    void Baseprint(){printf("now is Base.\n");}
    void changeid(int x){id=x;}
};
class Base1:public Base
{
  public:
    Base1(){}
    void Base1print(){printf("now is Base1.\n");}
};
class Base2:public Base
{
  public:
    Base2(){}
    void Base2print(){printf("now is Base2.\n");}
};
class Pri:public Base1,public Base2
{
  public:
    Pri(){};
    void Priprint(){printf("now is Pri.\n");}
};
int main()
{
  Pri pri;
  pri.changeid(3);//编译出错
  return 0;
}
```
为什么会编译出错

因为changeid(int)函数很明显是Base里的但是当派生类Pri调用的时候 不确定其属于Base1的继承部分还是Base2的继承部分

这样的会导致指针出错

为了只有一个Base拷贝为引入了虚拟继承
```
class Base
{
  protected:
    int id;
  public:
  	
    Base():id(0){}
    void Baseprint(){printf("now is Base.\n");}
    void changeid(int x){id=x;}
};
class Base1:virtual public Base//虚拟继承
{
  public:
    Base1(){}
    void Base1print(){printf("now is Base1.\n");}
};
class Base2:virtual ppublic Base//虚拟继承
{
  public:
    Base2(){}
    void Base2print(){printf("now is Base2.\n");}
};
class Pri:public Base1,public Base2
{
  public:
    Pri(){};
    void Priprint(){printf("now is Pri.\n");}
};
int main()
{
  Pri pri;
  pri.changeid(3);
  return 0;
}
```
virtual关键字的意思：如果没有Base拷贝就添加一个否则就使用已有的那一个

这将使得应用程序main()对于引用公共部分不再模糊

7)多继承与组合构造顺序

虚拟优先然后非虚拟都是虚拟或者非虚拟的话按照继承的顺序来

与构造函数的书写无关
```
class Base1
{
  public:
    Base1(){printf("now is Base1.\n");}
};
class Base2
{
  public:
    Base2(){printf("now is Base2.\n");}
};
class Base3
{
  public:
    Base3(){printf("now is Base3.\n");}
};
class Base4
{
  public:
    Base4(){printf("now is Base4.\n");}
};
class Object1
{
  public:
    Object1(){printf("now is Object1.\n");}
};
class Object2
{
  public:
    Object2(){printf("now is Object2.\n");}
};
class Now:public Base1,virtual public Base2,public Base3,virtual public Base4
{
  protected:
    Object1 ob1;
    Object2 ob2;		
  public:
    Now():Base4(),Base3(),Base2(),Base1(){printf("now is Now.\n");}		
};
int main()
{
  Now now;
  return 0;
}
```
Output
```
now is Base2.
now is Base4.
now is Base1.
now is Base3.
now is Object1.
now is Object2.
now is Now.
```
这些基本上是目前整理的我可能还会不定期更新的
查看全文

相关阅读:
Why we should overwrite the hashCode() when we overwrite the equals()
static dictionary methods of text compression
xtrabackup热备主库（带gtid），实时在线还原备库
 容器提示没有这个：libaio.so.1
ORACLE账户提示EXPIRED(GRACE)问题
 mysql批量插入测试数据
 记录一下一个脚本化修改sudo提权
 mysql从别的库dump数据下来，然后导入不同名字的其它库
 记一个mysql最简单的清理其二进制的过程
 查看当前数据库正在执行的事件

原文地址：https://www.cnblogs.com/tcswuzb/p/14464847.html

学习笔记 C++ 类与对象

类与对象

1.声明类

2.实例化对象

3.访问类的成员

4.关键字private和public

5.关键字private实现数据抽象

6.构造函数

7.析构函数

8.复制构造函数

9.结构不同于类的地方

10.声明友元

11.静态数据类型

静态成员数据

静态成员函数

12.继承

1).含义

2).派生类对于基类的调用

3).派生类的构造函数与析构函数

构造函数

要注意的是

析构函数

4)派生类对于访问控制的调整

5)多继承

6)虚拟继承

7)多继承与组合构造顺序

Output