侯捷C++面向对象编程（上）--complex部分

已于 2024-07-15 18:15:36 修改
阅读量585 收藏 16
点赞数 13
分类专栏： C++ 文章标签： c++ 笔记
于 2024-07-15 18:13:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75282028/article/details/140445057
版权

1.简介

目标

以良好的方式编写C++class

学习Classes之间的关系

2、头文件与类的声明

3、防卫式声明

4、complex部分分析（Class without pointer member）

1、内联函数

内联函数的特点：

2、访问级别

3、初值列(initial list)

构造函数的初值列的优点：

使用构造函数的初值列的注意事项：

4、默认构造函数构造函数的重载

4、构造函数放在private中

5、常量成员函数（const member functions）

1、常量成员函数的特点：

2、注意事项：

6、参数传递与返回值（pass / return by values VS pass /return by reference(to const)）

7、友元

1、友元的主要特点：

2、注意事项：

8、操作符重载

成员函数：

​编辑

​编辑

非成员函数

5、complex源码

1.简介

目标

  1. 以良好的方式编写C++class

    class without pointer members--Complex

    class with pointer members --String

  2. 学习Classes之间的关系

    继承（inheritance）

    复合（composition）

    委托（delegation）

2、头文件与类的声明

3、防卫式声明

#ifndef __COMPLEX__
#define __COMPLEX__
​
/*
*/
​
#endif

头文件保护的目的是确保头文件中的内容只被编译一次，即使该头文件被多个源文件包含。如果没有这种保护，可能会导致编译错误，例如重复定义类、函数等。

这样，当 Complex.h 被包含进多个源文件时，只有第一次包含时 __COMPLEX__ 宏未定义，Complex 类的定义会被编译。之后的包含由于 __COMPLEX__ 已经定义，预处理器会跳过类的定义，从而避免了重复定义的问题。

4、complex部分分析（Class without pointer member）

#include<iostream>
using namespace std;
#ifndef __COMPLEX__
#define __COMPLEX__
​
class complex{
public:
    complex(double r=0 ,double i = 0):re(r),im(i){}
    /*   complex(double r=0 ,double i = 0){re=r,im=i}*/
    /*如果用户提供有参构造函数，编译器不提供默认构造函数（默认构造函数通常没有参数，但它们可以具有带默认值的参数。）
    如果用户提供拷贝构造函数，编译器不提供其他构造函数*/
    complex& operator += (const complex&);
    double real() const { return re;}
/*类内定义的函数默认是内联的，但这并不意味着它们总是被内联。编译器会根据优化级别和其他因素来决定是否实际进行内联。对于模板类，即使成员函数不在类内定义，它们也是内联的，因为模板需要在每个实例化点生成代码。*/

    double imag() const { return im;}
​
private:
    double re,im;
    friend complex& __doapl (complex*,const complex&);
};
​
inline complex&
__doapl(complex* ths,const complex& r){
    ths->re += r.re;
    ths->im += r.im;
    return *ths;
}
​
inline complex&
complex::operator += (const complex& r){
    return __doapl(this,r);
}
​
inline complex
operator + (const complex& x,const complex& y){
    return complex(x.real()+y.real(),x.imag()+y.imag());
/*创建的临时对象，到下一行时，就会自动销毁，不能返回引用。创建的临时对象在栈。*/
}
​
inline complex
operator + (const complex& x,double y){
    return complex(x.real()+y,x.imag());
}
​
inline complex
operator + (double x, const complex& y){
    return complex(x + y.real(),y.imag());
}
​
ostream&
operator << (ostream& os,const complex& x){
    return os << "(" <<x.real() << "," << x.imag() << ")";
}
#endif

1、内联函数

在C++中，inline 关键字用于建议编译器将一个函数的调用替换为该函数的代码。这样做可以减少函数调用的开销，特别是对于那些小的、频繁调用的函数。然而，是否真正内联该函数最终由编译器决定，编译器会根据多种因素（如代码大小、优化级别等）来决定是否采用内联。

内联函数的特点：

  1. 减少调用开销：内联函数避免了函数调用的额外开销，如参数传递、栈帧的创建和销毁等。

  2. 代码膨胀：由于内联函数的代码会在每个调用点展开，这可能导致程序体积增大。

  3. 编译器决定：编译器可以选择不内联一个函数，即使它被声明为 inline。如果函数体较大或包含复杂的控制流语句（如循环和分支），编译器可能不会进行内联。

  4. 模板函数：模板函数默认是内联的，因为编译器需要在每个模板实例化点生成代码。

  5. 调试：内联函数可能会使调试稍微复杂一些，因为它们在源代码中的单一位置被展开到多个调用点。

  6. 优化：内联可以使得编译器有更多的优化机会，因为它可以看到函数调用的上下文。

  7. 成员函数：类内定义的函数默认是内联的，但这并不意味着它们总是被内联。

2、访问级别

3、初值列(initial list)

complex(double r=0 ,double i = 0):re(r),im(i){}
/*   complex(double r=0 ,double i = 0){re=r,im=i}*/

在C++11及以后的版本中，构造函数的初值列（也称为成员初始化列表或构造函数初始化列表）是一个强大的特性，它允许你在构造函数中直接初始化成员变量，包括直接初始化成员对象和基类。使用初值列可以提高代码效率，并且对于某些类型的成员变量是必须的。

构造函数的初值列的优点：

  1. 效率：对于非构造函数的对象，使用初值列可以直接初始化，避免了复制或移动构造函数的调用。

  2. 必要性：对于常量成员、引用成员或没有默认构造函数的对象成员，必须使用初值列进行初始化。

  3. 清晰性：初值列提供了一种清晰的方式来展示成员变量的初始化顺序和方式。

  4. 性能：对于大型对象，使用初值列可以减少临时对象的创建，从而提高性能。

使用构造函数的初值列的注意事项：

  • 顺序：在初值列中初始化成员变量的顺序应该与它们在类声明中的声明顺序相同。

  • 必要性：对于引用类型或常量类型的成员变量，必须使用初值列进行初始化。

  • 基类初始化：如果你的类继承自其他类，可以在初值列中初始化基类。例如，BaseClass(name) 就是用 name 对象来初始化基类 BaseClass。

  • 列表结束：在初值列的最后，可以有一个冒号 : 后面跟着空格，然后是构造函数体的开始。

  • 临时对象：使用初值列可以避免不必要的临时对象的创建，因为成员变量是直接使用提供的参数初始化的。

  • 移动语义：如果成员变量是右值引用类型，初值列可以利用移动构造函数来提高效率。

  • 异常安全：使用初值列可以提高异常安全性，因为成员变量的初始化是在构造函数体执行之前完成的，如果构造函数体中抛出异常，成员变量已经被正确初始化。

    4、默认构造函数构造函数的重载

  1. 带参数的默认构造函数:

    complex(double r=0, double i=0) : re(r), im(i) {}

    这个构造函数有两个参数 r 和 i，它们都有默认值0。这意味着当创建 complex 类的实例时，如果调用者没有提供这些参数的值，它们将默认为0。构造函数体内部使用了一个成员初始化列表来初始化成员变量 re 和 im。这里的 re 和 im 代表复数的实部和虚部。

  2. 无参数的默认构造函数:

    complex() : re(0), im(0) {}

    这个构造函数不接受任何参数，并且在成员初始化列表中将 re 和 im 初始化为0。这种构造函数通常用于创建一个默认的 complex 实例，其实部和虚部都设置为0。

    由于只能有一个默认构造函数，因此不要同时采用这俩种方式。实际上，通常应初始化所有的对象，以确保所有成员一开始就有已知的合理值。因此，用户定义的默认构造函数通常会给所有成员提供隐式初始值。

3、使用构造函数

对于自定义的有参的构造函数，有两种使用构造函数来初始化对象的方式：

  1. 第一种显示的调用

    complex comp = complex (10,5);

  2. 第二种隐式的调用

    complex comp (10,5);

  3. 需要注意的是，当使用默认构造函数初始化对象,隐式调用不能带括号，否则变成函数的声明：

complex comp ();//错误
​
complex comp;//不能带括号

4、构造函数放在private中

5、常量成员函数（const member functions）

在C++中，常量成员函数是指在其声明的末尾加上 const 关键字的成员函数。这样的函数不能修改其所属对象的状态，即不能修改类的任何成员变量。它们可以被用于读取对象的状态，但不允许修改对象的状态。

1、常量成员函数的特点：

  1. 不可修改对象状态：常量成员函数不能改变对象的任何成员变量。

  2. 可以调用其他常量成员函数：常量成员函数可以调用类的其他常量成员函数。

  3. 可以被常量对象调用：常量对象只能调用常量成员函数。

  4. 提高封装性：使用常量成员函数可以提高类的封装性，因为它们不会改变对象的状态。

2、注意事项：

  • 如果成员函数不修改对象的状态，最好将其声明为常量成员函数，这样可以提高代码的安全性和可读性。

  • 常量成员函数可以访问和返回对象的成员变量，但不能修改它们。

  • 常量成员函数不能调用非常量成员函数，否则会违反它们不能修改对象状态的原则。

  • 常量对象只能调用常量成员函数，因为它们的状态不能被修改。

常量成员函数是C++中实现封装和保护对象状态的重要工具，它们确保了对象的不可变性，这在多线程编程和函数式编程中尤为重要。

6、参数传递与返回值（pass / return by values VS pass /return by reference(to const)）

参考博客：细谈 C++ 返回传值的三种方式：按值返回、按常量引用返回以及按引用返回_常量引用返回值-CSDN博客

7、友元

在C++中，友元（Friend）是一种特殊的类成员或函数，它不属于类的私有或保护成员，但被授权可以访问类的私有（private）和保护（protected）成员。友元提供了一种方式，允许特定的函数或类访问另一个类的内部实现细节，即使这些细节本应是封装和隐藏的。

1、友元的主要特点：

  1. 访问权限：友元可以访问类的私有和保护成员，就像它们是类的成员函数一样。

  2. 非成员：友元函数不是类的成员，它们不属于类，但在类的定义中被声明。

  3. 类间关系：一个类可以声明另一个类的实例为其友元，或者声明另一个类的静态成员函数为其友元。

  4. 单向关系：友元关系是单向的，即如果类A是类B的友元，并不意味着类B自动成为类A的友元，除非显式声明。

  5. 声明方式：在类的定义中，使用 friend 关键字来声明友元。

2、注意事项：

  • 封装性：过度使用友元可能会破坏类的封装性，因为它允许非成员函数访问类的私有成员。

  • 控制范围：友元关系需要谨慎使用，因为它会扩大对类私有成员的访问范围。

  • 单向关系：友元关系不具有传递性，即友元的友元不一定是友元。

  • 类模板：在类模板中使用友元时需要特别注意，因为模板实例化可能会影响友元的可见性。

友元是C++中一个强大的特性，它提供了一种灵活的方式来访问类的私有成员，但应该谨慎使用，以避免破坏封装性和设计原则。

8、操作符重载

成员函数：
非成员函数

这些函数绝不可return by reference,因为，他们返回的必定是个local object。

ostream&
operator << (ostream& os,const complex& x){
    return os << "(" <<x.real() << "," << x.imag() << ")";
}

  1. 函数签名：函数的返回类型是ostream&，这意味着函数应该返回一个输出流的引用，这样它就可以被链式调用。

  2. 参数类型：第二个参数是一个const complex&类型的引用，这表明该函数不会修改传入的复数对象，并且可以通过引用来避免复制。

5、complex源码

#ifndef __MYCOMPLEX__
#define __MYCOMPLEX__

class complex; 
complex&
  __doapl (complex* ths, const complex& r);
complex&
  __doami (complex* ths, const complex& r);
complex&
  __doaml (complex* ths, const complex& r);


class complex
{
public:
  complex (double r = 0, double i = 0): re (r), im (i) { }
  complex& operator += (const complex&);
  complex& operator -= (const complex&);
  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&);
  friend complex& __doami (complex *, const complex&);
  friend complex& __doaml (complex *, const complex&);
};


inline complex&
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}

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

inline complex&
__doami (complex* ths, const complex& r)
{
  ths->re -= r.re;
  ths->im -= r.im;
  return *ths;
}

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

inline complex&
__doaml (complex* ths, const complex& r)
{
  double f = ths->re * r.re - ths->im * r.im;
  ths->im = ths->re * r.im + ths->im * r.re;
  ths->re = f;
  return *ths;
}

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

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));
}

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));
}

inline complex
operator * (const complex& x, const complex& y)
{
  return complex (real (x) * real (y) - imag (x) * imag (y),
			   real (x) * imag (y) + imag (x) * real (y));
}

inline complex
operator * (const complex& x, double y)
{
  return complex (real (x) * y, imag (x) * y);
}

inline complex
operator * (double x, const complex& y)
{
  return complex (x * real (y), x * imag (y));
}

complex
operator / (const complex& x, double y)
{
  return complex (real (x) / y, imag (x) / y);
}

inline complex
operator + (const complex& x)
{
  return x;
}

inline complex
operator - (const complex& x)
{
  return complex (-real (x), -imag (x));
}

inline bool
operator == (const complex& x, const complex& y)
{
  return real (x) == real (y) && imag (x) == imag (y);
}

inline bool
operator == (const complex& x, double y)
{
  return real (x) == y && imag (x) == 0;
}

inline bool
operator == (double x, const complex& y)
{
  return x == real (y) && imag (y) == 0;
}

inline bool
operator != (const complex& x, const complex& y)
{
  return real (x) != real (y) || imag (x) != imag (y);
}

inline bool
operator != (const complex& x, double y)
{
  return real (x) != y || imag (x) != 0;
}

inline bool
operator != (double x, const complex& y)
{
  return x != real (y) || imag (y) != 0;
}

#include <cmath>

inline complex
polar (double r, double t)
{
  return complex (r * cos (t), r * sin (t));
}

inline complex
conj (const complex& x) 
{
  return complex (real (x), -imag (x));
}

inline double
norm (const complex& x)
{
  return real (x) * real (x) + imag (x) * imag (x);
}

#endif   //__MYCOMPLEX__

edu zhang
关注
  • 13
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
侯捷C++面向对象高级编程之---（6）complex类实现
qq_41593516的博客
09-29 123
补充：
面向对象程序设计（C++）课件
09-22
面向对象程序设计（Object-Oriented Programming，OOP）是一种...通过深入学习这些知识点，你可以逐步掌握C++的面向对象编程技巧，从而能够编写出高效、易于维护的软件系统。这份C++课件将是你探索OOP世界的重要指南。
侯捷C++学习记录-面向对象高级编程上
qq_44092751的博客
10-23 455
侯捷C++面向对象高级编程
整合--侯捷--C++面向对象高级编程（一）
amzirl的博客
09-15 1358
侯捷
【C++】侯捷C++面向对象高级编程(上)
半生瓜のblog
09-09 1561
C++面向对象高级编程前言C++ Programs代码基本形式文件类型头文件写法头文件布局class1——complex类的声明inline——内联函数class访问级别(access level)构造函数(ctors)构造函数特有语法构造函数放到private?常量成员函数const member functions参数传递返回值友元friend同一个class的各个object互为友元操作符重载operator overloading(成员函数)操作符重载operator overloading(非成员
侯捷C++课程PPT及代码
11-19
PPT部分可能涵盖了C++的基础语法、面向对象编程、模板、STL（标准模板库）、异常处理、多线程等高级主题。代码部分则通过实际的程序实例，让学习者能够动手实践，加深对理论知识的理解。 【标签】：“侯捷C++课程...
侯捷-STL和泛型编程笔记1-4讲
03-28
侯捷——STL和泛型编程笔记1-4讲
侯捷-深度探索C++对象模型
11-05
5. **面向对象编程的关键特性**：C++支持封装、继承和多态三大面向对象编程特性。封装隐藏实现细节，提高代码安全性；继承允许创建新的类，基于已有的类扩展功能；多态则允许通过基类接口调用派生类的方法，实现灵活...
函数模板与类模板
程序员_小兵
07-12 1543
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
C++ 多态
wxk2227814847的博客
07-10 781
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++初探究（2）
Frenemy__的博客
07-09 1495
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C语言操作符详解
z317920的博客
07-11 625
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：哈希表
m0_61088872的博客
07-12 693
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 1013
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
[C++]——同步异步日志系统（3）
plj521的博客
07-10 1552
从本篇开始，正式开始写同步异步日志系统
C++中的多态：虚函数与纯虚函数详解
最新发布
TheJustice_的博客
07-14 292
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 404
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值