类和对象在内存中的关系

一个类的多个对象各自拥有类的数据成员的一个副本。

类的成员函数则被其所有对象共享。

一个类的不同对象响应相同的消息时，调用的是同一个函数。

下面举个例子：

class Student{private:Char name[21];Char no[4];Int age;Int score[5];
public:PrintStudent();Student();~ Student();GetTotal();GetAVG();
};

this指针

每个对象都有一个指向自身的this指针（对象的内存地址）

对象调用成员函数时会将自己的this指针传递给成员函数（隐含参数） PrintStudent(this);

成员函数访问对象的所有数据成员都是通过this指针访问

this指针的另外一个作用——访问对象自身（*this）

实例：

#include <iostream.h>
class Test {public:Test(int n = 0);Test & setData(int n);void print();
private:int data;
};
Test::Test(int n){this->data = n;       //data=n;
}
Test & Test::setData(int n) {data = n;     //this->data=n;return *this;
}
void Test::print() {cout<<"data = "<<data<<"!"<<endl;
}
void main() {Test obj1;cout<<"obj1: ";obj1.setData(100).print();
}执行结果：
obj1: data = 100!

类的静态成员

类的数据成员和成员函数都可以声明为static。

静态成员解决数据共享的问题。
-实现共享：在类外设置全局变量，但是，全局变量都有局限性,破坏类的完整性。

类的静态数据成员可以在类的范围内存储数据，这种数据独立于类类型中的任何对象，但可以由这些对象访问。

静态成员函数有一种独立于对象的计算能力。

类的非静态成员函数可以访问类的静态成员

静态数据成员

类中的普通成员对每个对象都有一个单独的副本实例。
类中的静态数据成员是该类所有对象所共同拥有的,只有一个实例，它不因对象的建立而产生，也不因对象的失效而删除，它是类定义的一部分，它属于整个类，即属于所有对象。

定义： static 数据类型数据成员名称;

初始化：静态数据成员不能由构造函数初始化，只能在类定义外使用::范围解析来完成
[static] 数据类型类名::数据成员名称=初始值;

访问：类名::静态数据成员

示例：

#include <iostream.h>class CFile
{private:char *m_fileName;
public:static bool saveState;File();File(char *fileName);
};
//定义初始化静态成员
bool CFile::saveState=true;int main()
{if(CFile::saveState==true){//文件已保存}else{//文件未保存}return 0;
}

静态成员函数

静态成员函数是操作静态数据成员的函数。

定义: static 返回类型函数名(参数列表)

访问：类名::静态成员函数

**注意：
①静态成员函数不能声明为const因为静态成员函数与类的对象无关，它没有this指针，所以不能用const关键字。
②静态成员函数不能访问类的非静态成员变量。
③静态成员函数不能调用非静态成员函数。
④静态成员函数的优点在于:即使不存在类的对象，它们也存在，并且可以调用。
⑤非静态成员函数可以访问静态数据成员，也可以调用静态成员函数。

实例：

#include <iostream.h>class MessageBox
{public:enum MessageBoxButtons{OK=0,YesNo=1,YesNoCancel=2};enum DialogResult{Yes=0,No=1,Cancel=3};static void Show(char *message);static DialogResult Show(char * message,MessageBoxButtons buttons);
};
void MessageBox::Show(char *message)
{cout<<message<<endl;
}
MessageBox::DialogResult MessageBox::Show(char *message, MessageBox::MessageBoxButtons buttons)
{cout<<message<<endl;switch(buttons){case OK:cout<<"OK"<<endl;break;case YesNo:cout<<"YesNo"<<endl;break;case YesNoCancel:cout<<"YesNoCancel"<<endl;break;}return Yes;
}
void main()
{MessageBox::Show("Sure Exit(y/n)?",MessageBox::YesNo);
}执行结果：
Sure Exit(y/n)?
YesNo

指针与对象

对象的指针:和一般的指针变量的声明和设定方式相同
Book a_book; //声明一个Book对象。
Book* book_ptr; //声明一个Book对象指针
book_ptr = &a_book;//把已有a_book对象赋值给对象指针

动态分配对象内存，利用new运算符声明对象并以动态分配内存的方式建立
类名* 指针名=new 类名(参数表);

取成员：
对象指针名-> 成员名
Delete 指针名;

对象参数的传递

函数传递参数的方式(传值/地址/引用)。

如果函数需要存储或更改对象成员变量中的数据，则必须通过引用将对象传递给它。

可以使用const修饰符禁止改变原始值

示例：

void call_by_ref(Book&);  //通过引用接受对象
void ring_by_ref(Book);   //按值传递
int main()
{Book a_book;call_by_ref(a_book);ring_by_ref(a_book)return 0;
}
void call_by_ref(Book& abook)
{······}

const 对象

如果把一个对象指定为const，就是告诉编译器不要修改它。

const对象的定义：const 类名对象名(参数表);

const对象不能调用非const成员函数

示例：

class Sample
{public:void GetValue() const {} // 常量成员函数void func(){}int m_value;
};void Sample::GetValue() const // 常量成员函数
{value = 0; // 出错func(); // 出错
}int main()
{const Sample obj;obj.value = 100; // 出错，常量对象不可以被修改obj.func();    // 出错,常量对象上面不能执行 非 常量成员函数obj.GetValue;   // OK,常量对象上可以执行常量成员函数return 0;
}

const 数据成员

和声明普通const变量的方法相同。

const数据成员的初始化：在构造函数使用初始化列表。

示例：

class ClassMember
{private:Student stu[100];int m_stuNum;
public:const int MAXCOUNT1;const int MAXCOUNT2;int GetStuNum() const;
};
ClassMember::ClassMember():MAXCOUNT1(10), MAXCOUNT2(20){this->m_Count=0;
}

const 成员函数

const成员函数不会修改调用它的对象。

const成员函数只能访问数据成员的值，而不能修改它

声明方式：在声明和定义的时候在函数头部的结尾加上 const 关键字

示例：

class Student
{public:int GetChinese() const;
private:int m_score[5];
};
int Student::GetChinese() const
{return m_score[0]; //相当于只读
}

存取权限的补充 mutable

用于定义更改频繁的数据成员. 数据成员即使在const对象或在const成员函数中都可以被修改

实例：

#include <iostream>
#include <string>
using namespace std;class CRect
{public:int getwid() const;
public:mutable int m_wid;
};
int CRect::getwid() const
{m_wid = 8;return m_wid;
}
int main()
{CRect re;re.getwid();printf("m_wid = %d\n",re.m_wid);return 0;
}执行结果：
8

复习笔记（三）——C++类和对象相关推荐

Ruby笔记三（类、对象、属性）
class Person #initialize是初始化方法,相当于Java的构造器.参数age有一个缺省值18, #可以在任何方法内使用缺省参数,而不仅仅是initialize.如果有缺省参 ...
Scal（三）——类与对象
Scala快速入门(三)--类与对象一.类这边类的模板如下,和Java很像 object a {def main(args: Array[String]): Unit = {val person= ...
第三章类与对象基础 ① 笔记
1. 内容回顾 1.1. 课前测试 1.2. 上节内容 2. 本章重点 2.1. 类和对象的概念 2.2. 类的基本组成 2.3. 构造方法 2.4. 成员方法 3. 具体内容 3.1. 类和对象的概 ...
Kotlin学习笔记第二章类与对象第十二十三节对象表达式与对象声明类型别名
参考链接 Kotlin官方文档 https://kotlinlang.org/docs/home.html 中文网站 https://www.kotlincn.net/docs/reference/p ...
C++阶段03笔记02【类和对象(封装、对象的初始化和清理、对象模型和this指针、友元、运算符重载、继承、多态)】
C++| 匠心之作从0到1入门学编程[视频+课件+笔记+源码] 目录 1.内存分区模型 2.引用 3.函数提高 4.类和对象 4.1.封装 4.1.1.封装的意义 --实例1:设计圆类 --实例2: ...
【Java学习笔记一】类和对象
面向对象程序设计的一个一个重要特点是:封装性. 这里的封装性有两方面含义:一是将有关的数据和操作代码封装在一个对象中形成一个基本单位,各个对象之间相互独立互不干扰,二是将对象中某些部分对外隐蔽,即隐蔽 ...
Kotlin学习笔记第二章类与对象第三节接口第四节函数式接口
参考链接 Kotlin官方文档 https://kotlinlang.org/docs/home.html 中文网站 https://www.kotlincn.net/docs/reference/p ...
学习笔记5（类和对象）
一.实例和静态 1.实例类中的实例都有自己的字段,再每个类中都可以创建一系列实例对象,并将值储存在实例字段中. box.setLength(10); 这段代码将10储存在一个被box引用的实例的字段 ...
java实验类和对象_ｊａｖａ　实验（三）类和对象
一.实验目的和要求 1. 掌握类的构造函数的重载 2. 深入理解类和对象 3. 学习NetBeans中UML项目的创建类并生成相应代码的方法二.实验内容和原理设计一个复数类,能够完成复数之间的基本 ...
python学习笔记：python类和对象，文件操作，网络编程
目录一.python面向对象 1.类和对象的定义 2.单继承 3.多继承 4.成员属性 5.异常 6.@property 二.python文件操作文件的打开和读写文件对象接口汇总三.pytho ...

复习笔记（三）——C++类和对象

目录