C++运算符重载的成员函数为什么不能访问本类的私有变量？_百度知道
C++运算符重载的成员函数为什么不能访问本类的私有变量？
学习C++运算符重载时，重载一元运算符“！”代码如下：//plus.hclass plus
friend plus operator+ (plus,plus);
friend int operator* (plus,plus);
bool operator! (const plus);
plus(){x=y=0;}
void set(int,int);
int getx();
我有更好的答案
没有加plus::的话，operator!就不是类的成员函数了啊至于提示，因为operator!不能有参数，因为是一元的嘛
为您推荐：
其他类似问题
运算符重载的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Python 3 教程
Python3 面向对象
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。
如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。
接下来我们先来简单的了解下面向对象的一些基本特征。
面向对象技术简介
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据。
语法格式如下：
class ClassName:
&statement-1&
&statement-N&
类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:
实例(Python 3.0+)
class MyClass:
&&&一个简单的类实例&&&
def f(self):
return 'hello world'
x = MyClass()
print(&MyClass 类的属性 i 为：&, x.i)
print(&MyClass 类的方法 f 输出为：&, x.f())
以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。
执行以上程序输出结果为：
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world
很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法（构造方法），像下面这样：
def __init__(self):
self.data = []
类定义了 __init__() 方法的话，类的实例化操作会自动调用 __init__() 方法。所以在下例中，可以这样创建一个新的实例:
x = MyClass()
当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:
实例(Python 3.0+)
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)
self代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
以上实例执行结果为：
&__main__.Test instance at 0x&
__main__.Test
从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。
self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:
class Test:
def prt(runoob):
print(runoob)
print(runoob.__class__)
t = Test()
以上实例执行结果为：
&__main__.Test instance at 0x&
__main__.Test
在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
实例(Python 3.0+)
class people:
__weight = 0
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(&%s 说: 我 %d 岁。& %(self.name,self.age))
p = people('runoob',10,30)
执行以上程序输出结果为：
runoob 说: 我 10 岁。
Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:
class DerivedClassName(BaseClassName1):
&statement-1&
&statement-N&
需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索
即方法在子类中未找到时，从左到右查找基类中是否包含方法。
BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):
实例(Python 3.0+)
class people:
__weight = 0
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(&%s 说: 我 %d 岁。& %(self.name,self.age))
class student(people):
grade = ''
def __init__(self,n,a,w,g):
people.__init__(self,n,a,w)
self.grade = g
def speak(self):
print(&%s 说: 我 %d 岁了，我在读 %d 年级&%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
执行以上程序输出结果为：
ken 说: 我 10 岁了，我在读 3 年级
Python同样有限的支持多继承形式。多继承的类定义形如下例:
class DerivedClassName(Base1, Base2, Base3):
&statement-1&
&statement-N&
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索
即方法在子类中未找到时，从左到右查找父类中是否包含方法。
实例(Python 3.0+)
class people:
__weight = 0
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(&%s 说: 我 %d 岁。& %(self.name,self.age))
class student(people):
grade = ''
def __init__(self,n,a,w,g):
people.__init__(self,n,a,w)
self.grade = g
def speak(self):
print(&%s 说: 我 %d 岁了，我在读 %d 年级&%(self.name,self.age,self.grade))
class speaker():
topic = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print(&我叫 %s，我是一个演说家，我演讲的主题是 %s&%(self.name,self.topic))
class sample(speaker,student):
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample(&Tim&,25,80,4,&Python&)
test.speak()
执行以上程序输出结果为：
我叫 Tim，我是一个演说家，我演讲的主题是 Python
如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：
实例(Python 3.0+)
class Parent:
def myMethod(self):
print ('调用父类方法')
class Child(Parent):
def myMethod(self):
print ('调用子类方法')
c = Child()
c.myMethod()
super(Child,c).myMethod()
函数是用于调用父类(超类)的一个方法。
执行以上程序输出结果为：
调用子类方法
调用父类方法
类属性与方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。
类的私有属性实例如下：
实例(Python 3.0+)
class JustCounter:
__secretCount = 0
publicCount = 0
def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)
执行以上程序输出结果为：
Traceback (most recent call last):
File "test.py", line 16, in &module&
print (counter.__secretCount)
# 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'
类的私有方法实例如下：
实例(Python 3.0+)
class Site:
def __init__(self, name, url):
self.name = name
self.__url = url
def who(self):
print('name : ', self.name)
print('url : ', self.__url)
def __foo(self):
print('这是私有方法')
def foo(self):
print('这是公共方法')
self.__foo()
x = Site('菜鸟教程', 'www.runoob.com')
以上实例执行结果：
类的专有方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方
运算符重载
Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：
实例(Python 3.0+)
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
以上代码执行结果如下所示:
Vector(7,8)
6个月前 (09-13)
感谢您的支持，我会继续努力的!
扫码打赏，你说多少就多少
记住登录状态
重复输入密码C++面向对象编程(一)：基于对象(无成员指针) - 文章 - 伯乐在线
& C++面向对象编程(一)：基于对象(无成员指针)
在面向对象编程中，和是两个非常重要和基本的概念，类(Class)包含成员数据和实现行为的函数，当然还提供构造函数来创建对象。如果是一些需要手动释放内存的语言，例如C++，还提供析构函数来帮助释放内存空间；如果是一些有垃圾回收机制的语言，比如Java，就不需要提供析构函数来释放内存，内存释放交给系统来管理。而对象(Object)是类的实例，每次创建一个对象都有不同的标识符来表示不同的对象，虽然对象中的数据有些是相同的，但它们是否相同根据标识符来判断的。
关于成员数据与函数
在C++中，Class有两个经典的分类：
Class without pointer member (complex复数类)
Class with pointer member (string字符串类)
一个是类的成员数据不含指针，一个是类的成员数据含指针。complex类来讲述成员数据不含指针。
complex类有两个数据成员：实部和虚部，它们的数据类型都是double，而不是指针；它还定义对复数的基本操作：加、减、乘、除、共轭和正弦等。
string类来讲述成员数据含指针。
string类有一个数据成员：字符指针s，它指向一串字符；它还定义对字符串的操作：拷贝，输出，附加，插入等。
Object-Based(基于对象) vs. Object-Oriented(面向对象)
类的设计主要分两类，基于对象和面向对象：
Object-Based：面对的是单个class的设计
Object-Oriented：面向的是多个classes的设计，class与class之间是有关系的：继承、组合或委托
大家先了解一下这两个概念，后面会有详细介绍。
C++代码基本形式
C/C++程序都有一个函数入口：main函数。当执行main函数时，大多数都会用到标准库(iostream)和自定义的类(complex)，所以用文件包含指令#include &iostream&来包含I/O标准库，#include “complex.h”来包含自定义类complex。它们之间的语法有一点不同，一个是用尖括号&&来专门包含系统文件和标准库，另一个是用双引号””来包含自定义的类和文件。
使用预处理中的文件包含，能够将一个大文件分离到各种不同职责类的头文件和实现文件。这样不仅减少文件体积而无需加载无用的代码，提供编译速度；还能够提高代码的复用性。
扩展文件名(extension file name)不一定是.h或cpp，有可能是.hpp或其他扩展文件名。
Header(头文件)防卫式声明
头文件经常#include其他头文件，甚至一个头文件可能被多次包含进同一个源文件。为了避免重复包含，使用大写的预处理器变量以及其他语句来处理。预处理器变量有两种状态：未定义和已定义；定义预处理器变量和检测其状态所用的预处理指示不同。
#define指示表示定义一个预处理变量，而ifndef指示检测预处理器变量是否未定义；如果未定义，那么跟在其后的所有指示都被处理，如果已经被定义，那么跟在其后的所有指示会跳过不处理。 部分示例代码如下：
complex.h头文件
#ifndef __MYCOMPLEX__
#define __MYCOMPLEX__
//Class Declaration
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d
#ifndef __MYCOMPLEX__#define __MYCOMPLEX__&//Class Declaration......&#endif
complex-test.c测试文件
#include &iostream&
#include "complex.h"
operator && (ostream& os, const complex& x)
return os && '(' && real (x) && ',' && imag (x) && ')';
int main()
complex c1(2, 1);
complex c2(4, 0);
cout && c1 &&
cout && c2 &&
cout && c1+c2 &&
cout && c1-c2 &&
cout && c1*c2 &&
cout && c1 / 2 &&
cout && conj(c1) &&
cout && (c1 += c2) &&
cout && (c1 == c2) &&
cout && (c1 != c2) &&
cout && +c2 &&
cout && -c2 &&
cout && (c2 - 2) &&
cout && (5 + c2) &&
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d
#include &iostream&#include "complex.h"&using namespace std;&ostream&operator && (ostream& os, const complex& x){&&&&return os && '(' && real (x) && ',' && imag (x) && ')';}&int main(){&&&&complex c1(2, 1);&&&&complex c2(4, 0);&&&&&cout && c1 && endl;&&&&cout && c2 && endl;&&&&&cout && c1+c2 && endl;&&&&cout && c1-c2 && endl;&&&&cout && c1*c2 && endl;&&&&cout && c1 / 2 && endl;&&&&&cout && conj(c1) && endl;&&&&&cout && (c1 += c2) && endl;&&&&&cout && (c1 == c2) && endl;&&&&cout && (c1 != c2) && endl;&&&&cout && +c2 && endl;&&&&cout && -c2 && endl;&&&&&cout && (c2 - 2) && endl;&&&&cout && (5 + c2) && endl;&&&&&return 0;}
Class的声明
首先给出complex类声明的代码，然后逐步来解析各个部分，示例代码如下：
// forward declarations (前置声明)
__doapl (complex* ths, const complex& r);
// class declarations (类声明)
class complex
complex (double r = 0, double i = 0): re (r), im (i) { }
complex& operator += (const complex&);
complex& operator -= (const complex&);
double real () const { }
double imag () const { }
double re,
friend complex& __doapl (complex *, const complex&);
// no-member function definition (非成员函数定义)
inline complex&
__doapl (complex* ths, const complex& r)
ths-&re += r.
ths-&im += r.
// class definition (类定义)
// operator overloading (成员函数-操作符重载)
inline complex&
complex::operator += (const complex& r)
return __doapl (this, r);
// operator overloading(非成员函数-操作符重载)
inline double
imag (const complex& x)
return x.imag ();
inline double
real (const complex& x)
return x.real ();
inline complex
operator + (const complex& x, const complex& y)
return complex (real (x) + real (y), imag (x) + imag (y));
inline complex
operator + (const complex& x, double y)
return complex (real (x) + y, imag (x));
inline complex
operator + (double x, const complex& y)
return complex (x + real (y), imag (y));
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d
// forward declarations (前置声明)class complex; complex&&&__doapl (complex* ths, const complex& r);&// class declarations (类声明)class complex{public:&&&&complex (double r = 0, double i = 0): re (r), im (i) { }&&&&&complex& operator += (const complex&);&&&&complex& operator -= (const complex&);&&&&&double real () const { return re; }&&&&double imag () const { return im; }&private:&&&&double re, im;&&&&friend complex& __doapl (complex *, const complex&);};&// no-member function definition (非成员函数定义)inline complex&__doapl (complex* ths, const complex& r){&&&&ths-&re += r.re;&&&&ths-&im += r.im;&&&&return *ths;}&// class definition (类定义)// operator overloading (成员函数-操作符重载)inline complex&complex::operator += (const complex& r){&&&&return __doapl (this, r);}&// operator overloading(非成员函数-操作符重载)inline doubleimag (const complex& x){&&&&return x.imag ();}&inline doublereal (const complex& x){&&&&return x.real ();}&inline complexoperator + (const complex& x, const complex& y){&&&&return complex (real (x) + real (y), imag (x) + imag (y));}&inline complexoperator + (const complex& x, double y){&&&&return complex (real (x) + y, imag (x));}&inline complexoperator + (double x, const complex& y){&&&&return complex (x + real (y), imag (y));}
更加详细的示例代码下载地址：
Access Level(访问级别)
上面有两个关键字public和private来标明数据成员和成员函数的访问级别，public表示类的外部能够访问类里面的数据或函数，而private表示类的外部不能访问类里面的数据和函数，只允许类内部来访问；通常使用private来修饰数据成员来封装数据，不让类外部的数据轻易访问。如果类外部的数据想访问，就定义一些public的accessors方法来暴露给外部接口来访问。
Constructor(构造函数)
如果你使用类来创建对象并初始化数据成员，就需要定义构造函数。complex类的构造函数定义如下：
// 使用初始化列表 (推荐使用)
complex (double r = 0, double i = 0)
: re(r), im(i)
// 使用初始化列表 (推荐使用)complex (double r = 0, double i = 0)&&&&: re(r), im(i){}
// 使用函数体 (不推荐使用)
complex (double r = 0, double i = 0)
// 使用函数体 (不推荐使用)complex (double r = 0, double i = 0){&&&&re = r;&&&&im = i;}
在定义构造函数时，需要指定类名complex，数据成员(double r = 0, double i = 0)作为参数和函数体，但并不需要返回值，它还为参数设置默认值(r = 0, i =0)。但有一个问题值得注意：究竟在哪里初始化数据成员呢？大多数的C++程序员都会在构造函数函数体来初始化，但有经验的C++程序员都会使用初始化列表。
从概念上讲，构造函数分为两个阶段执行：(1)使用初始化列表来初始化阶段；(2)普通的计算阶段，也就是构造函数的函数体中所有的语句。虽然complex类这个例子，使用其中一种方式会让最终效果一样，但有些情况只能使用初始化列表。看下面这个例子：
class ConstRef
ConstRef(int ii);
ConstRef::ConstRef(int ii)
// error: 不能给一个const赋值
// error: 不能绑定到其他对象，ri已经被初始化过
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d
class ConstRef{&&&&public:&&&&&&&&ConstRef(int ii);&&&&private:&&&&&&&&int i;&&&&&&&&const int ci;&&&&&&&&int &ri;}&ConstRef::ConstRef(int ii){&&&&i = ii;&&&&// ok&&&&ci = ii;&&// error: 不能给一个const赋值&&&&ri = i;&& // error: 不能绑定到其他对象，ri已经被初始化过}
注意：没有默认构造函数的类数据成员，以及const或引用类型的成员，不管哪种类型，都必须在构造函数初始化列表中进行初始化。
所以上面那个例子应该改为：
ConstRef::ConstRef(int ii)
: i(ii), ci(ii), ri(ii) {}
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d
ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(ii) {}
建议：使用构造函数初始化列表，而不是函数体来初始化数据成员。
重载(Overloaded)函数
在设计构造函数创建对象时，可能需要不同参数来创建对象，这时需要重载函数。
重载函数：出现在相同作用域中两个函数，如果有相同的名字而形参表不同，则称为重载函数。
就我们这个complex类的构造函数而言，有两个构造函数：
complex (double r = 0, double i = 0)
: re(r), im(i) {}
complex (double r) : re(r), im(0) {}
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d
complex (double r = 0, double i = 0): re(r), im(i) {}&complex (double r) : re(r), im(0) {}
第一个是有两个参数的构造函数，第二个是没有任何参数的构造函数，虽然它们的函数名相同，但由于它们的参数不同，C++编译器能够分辨出两个不同的函数，从而调用对应的构造函数。当使用complex c1(2, 3)创建对象时，对应会调用第一个构造函数。而当使用complex c2(2)创建对象时，对应会调用第二个构造函数。
当然，重载函数的概念不仅仅是用在构造函数，而应用在所有类型的函数，包括内联函数和普通的函数。
Inline(内联)函数
对于一些简单操作，我们有时将它定义为函数，例如：
// find longer of two strings
const string& shorterString(const string& s1, const string& s2)
return s1.size() & s2.size() ? s1 : s2;
// find longer of two stringsconst string& shorterString(const string& s1, const string& s2){&&&&return s1.size() & s2.size() ? s1 : s2;}
这样做的话，有几点好处：
使用函数可以确保统一的行为，并可以测试。
阅读和理解函数shorterString的调用，要比读一条用等价的条件表达式取代函数调用更加容易理解。
如果需要做任何修改，修改函数要比逐条修改条件表达式更加容易。
函数可以重用，不必为其他应用重写代码。
但简短的shorterString函数有个潜在的缺点：就是调用函数比求解条件表达式要慢的多，因为调用函数一般都要做以下工作：
调用前要先保存寄存器，并在返回时恢复
程序转向一个新位置执行。
内联函数避免函数调用的开销
如果使用内联函数，就可以避免函数调用的开销。编译器会将内联函数在程序中每个调用点“内联地”展开。假设我们将shorterString定义为内联函数，则调用：
cout && shorterString(s1, s2) &&
<div class="crayon-num" data-line="crayon-5ab7d
cout && shorterString(s1, s2) && endl;
在编译时就会展开为：
cout && s1.size() & s2.size() ? s1 : s2 &&
<div class="crayon-num" data-line="crayon-5ab7d
cout << s1.size() < s2.size() ? s1 : s2 << endl;
内联函数放在头文件
内联函数应该在头文件定义，这一点不同于其他函数，这样编译器才能在调用点内联展开函数代码。内联机制适用于只有几行且经常被调用的代码，如果代码行数或操作太多，即使你使用inline关键字来修饰函数，编译器也不会将它看作为内联函数。
Const(常量)成员函数
每个成员函数都有一个额外的、隐形的形参this，在调用成员函数时，形参this初始化为调用函数的对象地址。为了理解成员函数的调用，请看complex类这个例子：
complex c1 (2, 4); // create object
cout && c1.real() && // access const function real
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d
complex c1 (2, 4); // create objectcout && c1.real() && endl; // access const function real
编译器就会重写real函数的调用：
complex::real(&c1);
<div class="crayon-num" data-line="crayon-5ab7d
complex::real(&c1);
在这个调用中，在real函数的参数表中，有个this指针指向c1对象。如果在成员函数声明的形参表后面加入const关键字，那么const改变隐含this形参的类型，即隐含的this形参是一个指向c1对象的const complex*类型指针。因此，real函数对成员变量re所做操作是只能访问，而不能修改。同理，imag成员函数也是。
参数传递: pass by value vs. pass by reference
每次调用函数时，所传递的实参将会初始化对应的形参；参数传递有两种方式：一种是值传递，另一种就是引用传递。如果形参是使用值传递，那么复制实参的值；如果形参是引用传递，那么它只是实参的别名。看complex类这个例子中定义一个函数：
complex& operator+= (const complex& );
complex& operator+= (const complex& );
将&符号放在complex类后面，则表示调用函数式是使用引用传递来传递数据。为什么使用引用传递而不使用值传递呢？
值传递的局限性
当需要在函数中修改实参的值时
当传递的实参是大型对象时，复制对象所付出的时间和存储空间代价比较大
当没有办法实现对象复制时
参数传递选择
优先考虑引用传递(const)，避免复制
当在函数中处理后的结果是使用局部变量来存储，而不是形参的引用参数，使用值传递来返回。
Friend(友元)
在某些情况下，允许特定的非成员函数访问一个类的私有成员，同时仍然阻止一般的访问。例如，被重载的操作符，如输入或输出操作符，经常需要访问类的私有数据成员，这些操作不可能为类的成员；然而，尽管不是类的成员，它们仍是类的“接口组成部分”。
友元机制允许一个类将对其非公有成员的访问权授予指定的函数或类。友元的声明以关键字friend开始，它只能出现在类定义的内部。
以complex类为例，它有一个友元函数__doapl：
friend complex& __doapl (complex*, const complex&);
<div class="crayon-num" data-line="crayon-5ab7d
friend complex& __doapl (complex*, const complex&);
由于它参数是complex类，在函数内部需要访问到complex类的私有数据re和im，虽然可以通过real()和imag()函数来访问，但是如果直接访问re和im两个数据成员，就能提高程序运行速度。
重要提示： 相同class的各个objects互为friends(友元)
(Operator Overloading)操作符重载
C语言的操作符只能应用在基本数据类型，例如：整形、浮点型等。但C++的基本组成单元是类，如果对类的对象也能进行加减乘除等操作符运算，那么操作起来比调用函数更加方便。因此C++提供操作符重载来支持类与类之间也能使用操作符来运算。
操作符重载是具有特殊名称的函数：关键字operator后接需要定义的操作符符号。像任意其他函数一样，操作符重载具有返回值和形参表。
如果想操作符重载，有两种选择：
成员函数的操作符重载
非成员函数的操作符重载
两者之间有什么不同呢？对于成员函数的操作符重载，每次调用成员函数时，都会有一个隐含this形参，限定为第一个操作数，而this指针的数据类型是固定的，就是该类类型。而非成员函数的操作符重载，形参表比成员函数灵活，第一个形参不再限死为this形参，而是可以是其他类型的形参。下面我们分别通过两个例子来看看为什么这样选择。
成员函数的操作符重载
complex c1(2, 1);
complex c2 (5);
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d
complex c1(2, 1);complex c2 (5);&c2 += c1;
上面代码创建两个complex对象c1和c2，然后使用+=操作符来进行相加赋值操作。我们站在设计API角度来思考，如果重载操作符+=的话，需要提供两个参数(complex&, complex&)，但由于第一个参数类型是complex&跟成员函数this形参一样，所以优先考虑成员函数。
complex类重载+=操作符：
complex& operator += (const complex&);
<div class="crayon-num" data-line="crayon-5ab7d
complex& operator += (const complex&);
而代码实现放在类声明外面：
inline complex&
complex::operator += (const complex& r)
return __doapl (this, r);
inline complex&complex::operator += (const complex& r){return __doapl (this, r);}
非成员函数的操作符重载
complex c1(2, 1);
complex c2;
c2 = c1 + c2;
c2 = c1 + 5;
c2 = 7 + c1;
complex c1(2, 1);complex c2;&c2 = c1 + c2;c2 = c1 + 5;c2 = 7 + c1;
上面代码创建两个complex对象c1和c2，然后使用+操作符进行相加操作。
其中有一个c2 = 7 + c1代码片段，第一操作数是double，而不是complex。所以如果还是使用成员函数的话，编译器会报错，因为成员函数的第一个形参类型是complex而不是double。最后我们选择的是使用非成员函数来实现，而不是成员函数。
非成员函数重载+操作符：
inline double
imag (const complex& x)
return x.imag ();
inline double
real (const complex& x)
return x.real ();
inline complex
operator + (const complex& x, const complex& y)
return complex (real (x) + real (y), imag (x) + imag (y));
inline complex
operator + (const complex& x, double y)
return complex (real (x) + y, imag (x));
inline complex
operator + (double x, const complex& y)
return complex (x + real (y), imag (y));
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d
inline doubleimag (const complex& x){&&&&return x.imag ();}&inline doublereal (const complex& x){&&&&return x.real ();}&inline complexoperator + (const complex& x, const complex& y){&&&&return complex (real (x) + real (y), imag (x) + imag (y));}&inline complexoperator + (const complex& x, double y){&&&&return complex (real (x) + y, imag (x));}&inline complexoperator + (double x, const complex& y){&&&&return complex (x + real (y), imag (y));}
Temp Object(临时对象)
inline complex
operator + (const complex& x, const complex& y)
return complex (real (x) + real (y), imag (x) + imag (y));
<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d<div class="crayon-num crayon-striped-num" data-line="crayon-5ab7d<div class="crayon-num" data-line="crayon-5ab7d
inline complexoperator + (const complex& x, const complex& y){&&&&return complex (real (x) + real (y), imag (x) + imag (y));}
上面用非成员函数实现+操作符重载时，计算后结果没有使用引用形参来保存，而是使用一种特殊对象叫临时对象来保存，它是一个局部变量。语法是typename(data)，typename表示类型，data表示传入的数据。
当设计一个C++类的时候，需要思考一下问题：
首先要考虑它是基于对象(单个类)还是面向对象(多个类)的设计
类由数据成员和成员函数组成；一般来说，数据成员的访问权限应该设置为private，以防止类的外部随意访问修改数据。如果类的外部想访问数据，类可以定义数据成员的setter和getter。由于getter是不会改变数据成员的值，所以用const关键字修饰函数，防止getter函数修改数据
考虑完数据成员之后，然后考虑函数的设计。要创建对象，需要在类中定义构造函数。构造函数的参数一般是所有的私有数据成员，而要初始化数据成员，一般采用初始化列表，而不使用构造函数的函数体。
而对于一般的函数，在参数设计中，除了考虑变量名和数据类型之外，还要考虑参数传递、是否使用const修饰和有没有默认值等，参数传递优先考虑引用传递(避免复制开销)，而不是值传递，返回值也是一样。当在函数体内处理完结果之后，没使用引用形参来存储结果的话，可以使用临时对象存储并返回结果。有些函数实现只有几个操作的简短代码，将实现代码放在头文件，设置函数为inline。
当重载操作符时，可以使用两种方式来实现：成员函数和非成员函数。当第一个操作数是固定的类类型，优先使用成员函数，否则就使用非成员函数。
暂时总结这么多，后续还有其他C++面向对象编程的总结，会继续补充！！！
关于作者：
可能感兴趣的话题
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2018 伯乐在线
