C++面向对象高级编程(二)

版权声明:本文为博主原创文章,未经博主允许不得转载。

接下来的几篇文章,我将回忆一下C++的基础.

C++的由两部分组成 1.C++语言 2.C++标准库 本篇文章主要分享我学习C++语言的笔记.



这次主要回忆一下操作符重载.

先看一段代码,后续我会介绍这么做的原由

#include <iostream>
class complex
{
public:
    complex(double r = 0, double i = 0) : re(r) ,im(i) {}
    complex& operator += (const complex& r);
    double real() const { return re; }
    double imag() const { return im; }
    void real(double r);

private:
    double re,im;
    friend complex& __doapl (complex*, const complex&);
};

inline double
imag(const complex& x)
{
    return x.imag ();
}
inline double
real(const complex& x)
{
    return x.real ();
}


知识点1.重载成员函数

inline complex&
complex::operator += (const complex& r)
{
    return __doapl (this, r);
}

C++的调用都是从左面开始,下面调用

complex c1(1,2);
complex c2(2,3);
c1 += c2;

例如c1 += c2 他的完整含义应该是 c1 调用了 +=这个函数 传递的参数是两个其中一个是this(c1),另一个参数就是右边的值了(c2),[在编译器里别这样写,编译会报错]

//认识成员函数都有一个this point 指向调用者
//+=的完整形式应该是这样,谁调用这个函数谁就是this
inline complex&
complex::operator+=(this,const complex& r)
{
    return __dopal(this, r);
}


知识点2 . return by value, return by reference

//2.return by reference
inline complex& //引用接收 提高效率 还有一个重要的知识点 以备调用者 调用c3 += c2 += c1;
__doapl(complex* ths, const complex& r)
{
    ths->re += r.re;
    ths->im += r.im;
    return *ths; //返回的是对象, 接收却是引用,   这是C++的一个重要知识点,传递着无需知道接收者以什么形式接收
}

为什么 用引用接收  就可以让调用者调用c3 += c2 += c1;

如果你不用引用接收那么你第一次调用即c3 += c2时返回的即将是一个临时变量,那么在次调用c1时  c3 += c2 将毫无意义



知识点3 重载非成员函数

//3. 操作符重载 非成员函数 无this
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));
}

临时对象:typename() 创建临时对象 为什么上面的三个返回值不是reference 因为他们返回的一定是局部变量

知识点2.是左边 = 左边+ 右边 左边是一直存在的



知识点4 重载操作符

//<< 重载  由于这个操作符不认识我们新创建的对象我们需要重载
//千万不要把这个操作符写成成员函数 必须写成全局的
std::ostream&
operator << (std::ostream& os, const complex& x)  //这里的os就是cout 其实cout是一个类 别用const修饰  传引用为了能够相应连续调用
{
    return os << ‘(‘ << real (x) << ‘,‘
    << imag (x) << ‘)‘;
}

总结

1.传递着无需知道接收者以什么形式接收

2.接收者(返回值)是 by value还是 by reference,  by value 一般返回临时变量和将创建出的对象 , by reference 一般是在已经存在的对象上做修改

3.操作符重载不要加const ,不要声明称成员函数

如有不正确的地方请指正

参照<<侯捷 C++面向对象高级编程>>

时间: 2024-10-06 05:16:24

C++面向对象高级编程(二)的相关文章

Python笔记7#面向对象高级编程二

▲定制类 Python中有许多类似__slots__这样有特殊用途的函数,可以帮助我们定制类. 官方文档链接:https://docs.python.org/3.4/reference/datamodel.html#special-method-names 1)__str__和__repr__ 示例代码如下: >>> class Student(object): ... def __init__(self, name): ... self.name = name ... >>

C++面向对象高级编程(九)Reference与重载operator new和operator delete

摘要: 技术在于交流.沟通,转载请注明出处并保持作品的完整性. 一 Reference 引用:之前提及过,他的主要作用就是取别名,与指针很相似,实现也是基于指针. 1.引用必须有初值,且不能引用nullptr 2.引用之后不能再引用别人 3.引用通常不用于声明变量,多用于参数类型,和返回值类型 见下面代码 int main(int argc, const char * argv[]) { int x=0; //p is a pointer to x int* p = &x; // r is a

C++面向对象高级编程(三)

版权声明:本文为博主原创文章,未经博主允许不得转载. 接下来的几篇文章,我将回忆一下C++的基础. C++的由两部分组成 1.C++语言 2.C++标准库 本篇文章主要分享我学习C++语言的笔记. 本节主要介绍 Big Three 即析构函数,拷贝构造函数,赋值拷贝函数,前面主要围绕不带指针的class complex本节中主要围绕带指针的String类 前面我说过如果你创建的类不带有指针,那么多半你可以不用写析构函数,但是如果你创建了一个带指针的类,那么你必须重写Big Three 创建一个类

Python3 面向对象 高级编程

正常情况下,当我们定义了一个class,创建了一个class的实例后,我们可以给该实例绑定任何属性和方法,这就是动态语言的灵活性.  class Student(object): pass 然后,尝试给实例绑定一个属性: >>> s = Student() >>> s.name = 'Michael' # 动态给实例绑定一个属性 还可以尝试给实例绑定一个方法: >>> def set_age(self, age): # 定义一个函数作为实例方法 ...

C++面向对象高级编程(七)point-like classes和function-like classes

技术在于交流.沟通,转载请注明出处并保持作品的完整性. 1.pointer-like class 类设计成指针那样,可以当做指针来用,指针有两个常用操作符(*和->),所以我们必须重载这两个操作 /*简单实现一下智能指针的*与 -> 操作符*/ template <class T> class shared_ptr_test { public: T& operator* () const //重载* { return *px; } T* operator->() co

C++面向对象高级编程(六)转换函数与non-explicit one argument ctor

技术在于交流.沟通,转载请注明出处并保持作品的完整性. 1.conversion function 转换函数 //1.转换函数 //conversion function //只要你认为合理 你可以任意写转换函数 class Fraction { public: Fraction(int num, int den = 1):m_numerator(num),m_denominator(den){} operator double() const //注意看 没有返回类型,这个编译器会帮做,且防止

[7]面向对象高级编程

[7]面向对象高级编程 数据封装.继承和多态只是面向对象程序设计中最基础的3个概念.在Python中,面向对象还有很多高级特性,允许我们写出非常强大的功能. 我们会讨论多重继承.定制类.元类等概念. 使用__slots__ 正常情况下,当我们定义了一个class,创建了一个class的实例后,我们可以给该实例绑定任何属性和方法,这就是动态语言的灵活性.先定义class: >>> class Student(object): ... pass ... 然后,尝试给实例绑定一个属性: >

Boolan C++面向对象高级编程学习第五周

本周C++面向对象高级编程编程主要是讲三个方面 1.虚表和虚指针 虚指针:如果类(包括父类)中有虚函数,就一定会有虚指针,虚指针是指向虚函数的虚表. 虚表:虚指针指向的一种类的表,表上存有类里面虚函数的实现的指针 这里虚函数和虚表一般是和类的多太性结合在一起来使用的,子类调用虚函数是通过调用虚指针来调用虚函数表里面的指针再来实现函数特性 这种调用的方式叫做动态绑定,是一种通过指针类型自动来判断调用的对象,在实现中可以不用区分哪个对象从而调用对应的函数 我们普通的调用类里面的函数叫做静态绑定 2.

python基础-面向对象高级编程

实例化对象绑定属性 s.name = 'Michael' # 动态给实例绑定一个属性 类绑定方法---所有实例化对象均可调用Student.set_score = set_score 实例化对象绑定方法---只有该对象可调用from types import MethodType#绑定方法需要使用MethodTypes.set_age = MethodType(set_age, s) # 给实例绑定一个方法 Python内置的@property装饰器就是负责把一个方法变成属性调用的把一个gett