学习笔记 C++ 类与对象

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了学习笔记 C++ 类与对象，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8240字，纯文字阅读大概需要12分钟。

内容图文

类与对象

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

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++作为面向对象的程序设计语言的特点：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;
}

运行结果如下:

学习笔记 C++ 类与对象 - 文章图片

如果你可以看懂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;
}

这些基本上是目前整理的我可能还会不定期更新的

内容总结

以上是互联网集市为您收集整理的学习笔记 C++ 类与对象全部内容，希望文章能够帮你解决学习笔记 C++ 类与对象所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/601200.html

来源：【匿名】

【上一篇】VS Code运行C和C++程序【下一篇】c++有个库什么的吗?

更多 ►

【学习笔记 C++ 类与对象】教程文章相关的互联网学习教程文章

原型模式（Prototype)：用原型实例制定创建对象的种类，并且听过拷贝这些原型创建新的对象。浅复制：如果字段是值类型的，则对该字段执行逐位复制，如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其副本引用同一对象。深复制：把引用变量的对象指向复制过的新对象，而不是原有的被引用的对象。Effective C++:1：在资源管理类中提供对原始资源的访问。（1），APIs 往往要求访问原始资源（raw resources），所...

C++学习笔记32:泛型编程拓展1

标准模板库的内容标准模板类：复数、序偶迭代器标准容器：向量，表，栈，队列，集合，映射等标准算法：查找，排序等标准模板库型式的使用方法“<>”：模板名称<数据对象基型式>数据对象名称；例子1：complex<double>a(1.0,2.0);例子2：pair<string,string>name("zhang","san");(序偶)例子3：vector<int>v(8); 复数一般说明头文件：“complex”模板名：complex<>基型式：float,double,long double首选double,float精度低，long doub...

C++学习笔记（十六）：友元【代码】

问题的提出：我们已知道类具备封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程式中的其他函数是无法访问私有成员的。非成员函数能够访问类中的公有成员，但是假如将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程式的运行效率。友元是一种定义在类外部的普通函数，但他需要在类...

吴裕雄--天生自然C++语言学习笔记：C++ 类 & 对象【代码】

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。键字 class 定义 Box 数据类型，如下所示： class Bo...

c++学习笔记——构造函数

构造函数定义：每个类都分别定义了它的对象被初始化的方式，类通过一个或几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做构造函数。需要注意的几点：1：构造函数不能被声明为const的，当我们创建一个const对象时，直到构造函数完成初始化过程，对象才能真正取得其“常量”属性。因此构造函数在const对象的构造过程中可以向其写值。2：只有类中没有声明任何构造函数时，编译器才会自动地生成默认构造函数。（依据：如果一...

C++学习笔记(一)【代码】

C++包括面向对象开发的三大特性封装性继承性多态性封装性封装的目标：实现软件部件的“高内聚、低耦合”，防止程序相互依赖而带来的变动影响。封装的思路：面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性对应于变量，行为对应于方法，方法可以直接访问同一个对象中的属性。个人想法：一般来说，我们把类的成员变量定义为private类型，成员函数定义成public类型。C语言中也提供了一...

Effective C++学习笔记(Part Seven:Item 41-48)

??最近终于把effectvie C++仔细的阅读了一边，很惊叹C++的威力与魅力。最近会把最近的读书心得与读书笔记记于此，必备查找使用，如果总结有什么不当之处，欢迎批评指正：现在只列出框架，最近会尽快填充完整：第7部分：模板与泛型编程所谓泛型编程就是以独立于任何特定类型的方式编写代码。使用泛型程序时，我们需要提供具体程序实例所操作的类型或值。模板是泛型编程思想的一种实现，也是C++研发者思想精髓所在。条款41：...

c++ 11学习笔记--Lambda 表达式（对比测试Lambda ，bind，Function Object）【代码】

所有c++ coder都应该为这个语法感到高兴，说的直白一点，Lambda 表达式就是函数对象的语法糖。还是直接看对比栗子吧，抄袭的是msdn的官网该示例使用 for_each 函数调用中嵌入的 lambda 向控制台打印 vector 对象中的每个元素是偶数还是奇数。使用lambda#include <algorithm> #include <iostream> #include <vector> usingnamespace std;int main() {// Create a vector object that contains 10 elements.vector<int> v;for (int...

c++学习笔记1（c++简介）

c++和c的不同：　　1，c++是c的扩充。　　2，在解决问题时思维方式的不同。（c++采用面向对象思维，c面向结构思维）面向结构思维：将一个大程序拆分成一个个很小的结构。每个结构完成一个或多个功能，所有结构集合起来就可以完成一个大功能。结构是实现一个或多个功能的代码块。缺点：可维护性、数据的安全性（只是把大程序细化成若干个小结构，并没有考虑数据的安全性问题）（数据是属于整个程序的）、可重用性（并没有将相关的数...

C++ set容器用法学习笔记【图】

set集合容器实现了红黑树(Red-Black Tree)的平衡二叉检索树的数据结构，在插入元素时，他会自动调整二叉树的排列，把该元素放到合适的位置上，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得保证根节点左子树的高度与右子树的高度相等，这样，二叉树的高度最小，从而检索的速度最快。要注意的是，他不会重复插入相同键值的元素，二采取忽略处理，如下图所示：平衡二叉检索树的...

C++面向对象程序设计学习笔记（6）【代码】

多态性编译时的多态性与运行时的多态性在面向对象方法中，所谓多态性就是不同对象收到相同信息时，产生不同的行为。在c++程序设计中，即“一个接口，多种方法” 在C++中，多态性的实现和联编这一概念相关，一个源程序经过编译、连接，称为可执行文件的过程即为把可执行代码联编在一起的过程。其中在运行前完成的称为静态联编，又称前期联编，而在运行时完成的称为动态联编，也称后期联编静态联编支持的多态性称为编译时多态性，也...

《C++ 101条建议》学习笔记——第一章快速入门

1.C++程序组成：a.编译指示，由#开始，不由分号结束。只是影响编译过程。b.声明语句，影响编译过程，编译结果中并不会生成对应的指令。只是告诉编译器一些信息。c.可执行过程语句，生成对应的指令。包括：简单语句、复合语句、控制语句、try语句等。d.函数（返回类型，函数名称，参数列表，函数体）。函数名称说明函数的功能，返回值返回函数执行后的输出结果，形式参数表示函数的输入或输出，函数体决定函数的执行过程。2.面向过程...

C++11 virtual函数学习笔记【代码】

#include<iostream>#include<string>using namespace std; class Base { public:Base(){}~Base(){} public:virtual void f1(int x){ cout << "baseclass: f1() " << x << endl; }virtual void f2()final{ cout << "baseclass: f2() " << endl; }void f3(int x){ cout << "baseclass : f3() " <<x<< endl; }virtual void f4(){ cout << "baseclass:f4()" << endl; }//string isbn()const;//virtual double net_price(size_t n)cons...

C++学习笔记42：进程管理【代码】

子进程异步清除　　SIGCHLD信号：子进程终止时，向父进程自动发送，编写此信号处理例程，异步清除子进程#include <signal.h> #include <string.h> #include <sys/types.h> #include <sys/wait.h>sig_atomic_t child_exit_status; extern"C" {void CleanUp(int sig_num){int status;wait(&status); //清除子进程child_exit_status = status; //存储子进程的状态 } }int main() {//处理SIGCHLD信号struct sigactio...

C++ Primer Plus学习笔记之继承类的初始化顺序

C++ Primer Plus学习笔记之继承类的初始化顺序基类的构造函数，析构函数和操作符函数operator=是不能被派生类继承的；那么，当创建一个派生类对象时，怎样调用基类的构造函数对基类的数据进行初始化呢？？？答案是：构造函数执行时遵行先兄长(基类)，再客人(对象成员)，后自己(派生类)的顺序；另一方面，执行析构函数时，先执行派生类的析构函数，再执行基类的析构函数。原因是，对基类的破坏隐含了对派生类的破坏，所以派生类的析...

C++ - 技术教程分类

C++ 教程 C++ 简介 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 数据结构 C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口（抽象类） C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程 C++ 标准库 C++ 有用的资源 C++ 实例 c++ 全部

C++ - 最热教程

C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档 C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo [C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体

首页 / C++ / 学习笔记 C++ 类与对象

学习笔记 C++ 类与对象

内容导读

内容图文

类与对象

1.声明类

2.实例化对象

3.访问类的成员

4.关键字private和public

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

6.构造函数

7.析构函数

8.复制构造函数

9.结构不同于类的地方

10.声明友元

内容总结

内容备注

内容手机端

【学习笔记 C++ 类与对象】教程文章相关的互联网学习教程文章

原型模式和Effective C++学习笔记

C++学习笔记32:泛型编程拓展1

C++学习笔记（十六）：友元【代码】

吴裕雄--天生自然C++语言学习笔记：C++ 类 & 对象【代码】

c++学习笔记——构造函数

C++学习笔记(一)【代码】

Effective C++学习笔记(Part Seven:Item 41-48)

c++ 11学习笔记--Lambda 表达式（对比测试Lambda ，bind，Function Object）【代码】

c++学习笔记1（c++简介）

C++ set容器用法学习笔记【图】

C++面向对象程序设计学习笔记（6）【代码】

《C++ 101条建议》学习笔记——第一章快速入门

C++11 virtual函数学习笔记【代码】

C++学习笔记42：进程管理【代码】

C++ Primer Plus学习笔记之继承类的初始化顺序

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程