精华内容
下载资源
问答
  • 《重学C++ 重构你的C++知识体系》笔记汇总
    千次阅读 热门讨论
    2020-10-27 10:18:48

    前言

    觉得这门课特别好,决定认认真真学习下,带好耳机,做好笔记!

    索引

    总结

    加快学习的步伐呀!

    更多相关内容
  • c++ 重构知识点

    2021-09-06 14:41:59
    一、静态转为动态 二、早绑定转变为晚绑定 绑定:将函数体和函数调用关联起来 早绑定,在程序运行之前(也就是编译和链接时) 迟绑定发生在运行时,基于不同类型的对象。当一种语言实现迟绑定时,必须有某种机制...

    一、静态转为动态

    二、早绑定转变为晚绑定

    • 绑定:将函数体和函数调用关联起来
    • 早绑定,在程序运行之前(也就是编译和链接时)
    • 迟绑定发生在运行时,基于不同类型的对象。当一种语言实现迟绑定时,必须有某种机制确定对象的具体类型然后调用合适的成员函数。
    例子
    class Animal
    {
    public:
    	virtual void sleep()  //虚函数
    	{
    		cout << "Animal sleep!" << endl;
    	}
     
    	void breath()
    	{
    		cout << "Animal breath!" << endl;
    	}
    };
     
    class Fish :public Animal
    {
    public:
    	void sleep()   //函数重写,这里可以添加virtual,也可以不添加
    	{
    		cout << "Fish sleep!" << endl;
    	}
    	void breath()
    	{
    		cout << "Fish breath!" << endl;
    	}
    };
    int main()
    {
    	Fish f;
    	Animal* a = &f; //基类指针指向派生类
    	a->breath();
    	a->sleep();
    	return 0;
    }
    // 结果:  Animal breath!
    //        Fish sleep!
    
    //结果解析:a是指向Animal(基类)的指针,指向派生类对象,调用基类的breath()函数;
    //调用sleep(派生类 )的Fish sleep。 sleep函数是虚函数,在Fish中重写(覆盖)了基类;
    //但breath()函数不是虚函数,在Fish(派生类)里面也有一个同名的函数,发生了同名隐藏。
    

    在这里插入图片描述

    早绑定的优点是:
    • 编译效率
    • 代码提示(代码智能感知)
    • 编译时类型检查
    晚绑定的优点是:
    • 不用申明类型
    • 对象类型可以随时更改

    三、继承转变为组合

    优先使用对象组合,而不是类继承。

    示例
    class Eye
    {
    public:
      void Look(void);
    };
    
    class Nose
    {
    public:
      void Smell(void);
    };
    
    class Mouth
    {
    public:
      void Eat(void);
    };
    
    class Ear
    {
    public:
      void Listen(void);
    };
    
    // 正确的设计,冗长的程序
    class Head
    {
    public:
      void Look(void) { m_eye.Look(); }
      void Smell(void) { m_nose.Smell(); }
      void Eat(void) { m_mouth.Eat(); }
      void Listen(void) { m_ear.Listen(); }
    private:
      Eye m_eye;
      Nose m_nose;
      Mouth m_mouth;
    Ear m_ear;
    };
    
    

    四、编译时依赖转变为运行时依赖

    五、紧耦合转变为松耦合

    展开全文
  •  由于C++的复杂性,导致业界对C++的自动化重构工具支持一直非常不理想.很多重构到目前为止只能手工进行. 重构工具对语言的支持的一个难点在于对代码引用点的分析查找. C++中有很多语法会干扰到这一分析,导致难以...
  • 下面小编就为大家带来一篇重构-C++实现矩阵的简单实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • C++如何重构操作符

    千次阅读 2019-09-09 18:28:11
    C++和C一样有很多的操作符,如表示逻辑运算的&,|,~,!以及表示数字运算的+,-,*,/,++,–和表示判断的==,&&,||等等。但是在C中这些符号只能用于处理特定类型的数据。但是在C++中可以对部分的...

    C++和C一样有很多的操作符,如表示逻辑运算的&,|,~,!以及表示数字运算的+,-,*,/,++,–和表示判断的==,&&,||等等。但是在C中这些符号只能用于处理特定类型的数据。但是在C++中可以对部分的操作符重载,已达到操作自定义的类型的数据。C++中可以重载的操作符有:

    用途符号
    算术运算+,-,*,/
    自增自减++,–
    比较==,!=,>,<.<=,>=
    逻辑判断&&
    输入输出>>,<<
    赋值=,+=,-=,*=,/=,<<=,>>=,&=
    位逻辑&,^,~,<<,>>
    其他->,new,delete

    等。
    下面举几个简单的例子来解释如何使用操作符重载手法。

    1. 复数相加:
      在C++中可以用一个类来表示复数,但是要想将两个复数想加,就必须要在类中重写一个方法,为了简便,可以直接对“+”操作符直接将两个复数相加。
    #include <iostream>
    
    using namespace std;
    
    class Complex{
        int real;
        int imag;
    public:
        Complex(int x, int y):real(x),imag(y){}
    
        int getReal()const{
            return real;
        }
    
        int getImag()const{
            return imag;
        }
    
        Complex operator+(Complex& b){   //在类中重构“+”运算符,传入需要相加的对象
            Complex c(this->real+b.getReal(), this->imag+b.getImag()); //创建一个新的类,并将二者的实部加实部虚部加虚部
            return c;  //返回这个新的对象
    }
    
    };
    
    
    int main(){
        Complex a(2,3);  //创建两个对象
        Complex b(4,5);
        Complex c = a + b;  //这样的,对象c就可以直接写成a+b了
        cout << "the first complex number: " << a.getReal() << " + " << a.getImag() << "i" << endl;
        cout << "the second complex number: " << b.getReal() << " + " << b.getImag() << "i" << endl;
        cout << "the result of plus 2 complex number: " << c.getReal() << " + " << c.getImag() << "i" << endl;
    }
    

    以上就直接重构了"+"操作符,大大的简化了代码的内容。同样的输出结果的时候代码太复杂了,同理也可以对输出符进行重载:

    #include <iostream>
    #include <sstream>
    
    using namespace std;
    
    class Complex{
        int real;
        int imag;
    public:
        Complex(int x, int y):real(x),imag(y){}
    
        int getReal()const{
            return real;
        }
    
        int getImag()const{
            return imag;
        }
    
        Complex operator+(Complex& b){   //在类中重构“+”运算符,传入需要相加的对象
            Complex c(this->real+b.getReal(), this->imag+b.getImag()); //创建一个新的类,并将二者的实部加实部虚部加虚部
            return c;  //返回这个新的对象
    }
    
    };
    
    
    ostream& operator<<(ostream& ss, Complex& x){  //重载输出函数时需要将输出流ostream作为参数传入。同样的如果是对输入函数重载则需要将输入流instream'传入
        ss << x.getReal() << " + " << x.getImag() << "i" << endl;
        return ss;
    
    }
    
    int main(){
        Complex a(2,3);  //创建两个对象
        Complex b(4,5);
        Complex c = a + b;  //这样的,对象c就可以直接写成a+b了
        cout << "the first complex number: " << a.getReal() << " + " << a.getImag() << "i" << endl;
        cout << "the second complex number: " << b.getReal() << " + " << b.getImag() << "i" << endl;
        cout << "the result of plus 2 complex number: " << c.getReal() << " + " << c.getImag() << "i" << endl;
        cout << "\n===========================================\n";
        //通过对输出操作符重载后使代码变得更加简洁
        cout << "the first complex number: " << a;
        cout << "the second complex number: " << b;
        cout << "the result of plus 2 complex number: " << c;
    }
    

    这里需要注意的是,重载“+”时是写在类里面的而对输出流进行重载则是写成一个全局函数。如果无法理解的话,可以想象成对类中方法的调用。也可以写成:

    Complex c = a.operator+(b);
    

    这样就是对类中的方法的调用,另外一个对象以参数的方式传入。同样的也可以对其他的操作符做重载。比如复数相乘:

    Complex operator*(Complex& c){
            Complex x(this->real * c.getReal() - this->imag * c.getImag(), this->real * c.getImag() + this->imag * c.getReal());
            return x;
        }
    
    展开全文
  • 重构源代码C1-c++版本

    2017-08-24 17:55:00
    自己手动写的c++版本的重构例子。原书上是Java的。实测可行
  • 重构 重构是对程序内部的架构的调整。 重构强调的是在不改变"软件外部可观察的行为"前提下,对内部结构进行调整,使得从程序的外部功能上看,没有任何变化。 如下例子: 重构前代码如下: #include <iostream>...

    重构

    重构是对程序内部的架构的调整。
    重构强调的是在不改变"软件外部可观察的行为"前提下,对内部结构进行调整,使得从程序的外部功能上看,没有任何变化。
    如下例子:
    重构前代码如下:

    #include <iostream>
    
    class child
    {
    private:
    public:
        child(){};
        void func(){
            std::cout << 123 << std::endl;
        }
    
    };
    
    int main(int argc, char const *argv[])
    {
        child a;
        a.func();
        return 0;
    }
    

    程序运行后,输出123.
    重构后的代码如下:

    #include <iostream>
    
    class child
    {
    private:
    public:
        child(){};
    
        void f1(){std::cout << 1;}
        void f2(){std::cout << 2;}
        void f3(){std::cout << 3;}
    
        void func(){
            f1();
            f2();
            f3();
            std::cout << std::endl;
        }
    
    };
    
    int main(int argc, char const *argv[])
    {
        child a;
        a.func();
        return 0;
    }
    

    main函数执行的时候,依然是调用a的func方法,程序的输出也是123,对于外部来说没有任何改变,但是func内部的实现方式已经改变。

    重写

    重写(override)也叫覆盖。

    明确一个概念:“函数签名”,函数签名不仅仅包括函数名,还包括函数的参数、参数的个数、参数的顺序、所在命名空间等信息。但是函数签名不包括函数的返回值类型,如果两个函数除了返回值类型不同以外,其他都一模一样,这在C++中是不被允许的。

    重写是指不改变函数签名,改变的是一个函数内部。如下代码:

    #include <iostream>
    
    class parent
    {
    private:
    public:
        parent(){};
        virtual void func(){
            std::cout << 123 << std::endl;
        }
    
    };
    
    class child : parent{
    public:
        void func(){
            std::cout << 456 << std::endl;
        }
    
    };
    
    int main(int argc, char const *argv[])
    {
        child a;
        a.func();
        return 0;
    }
    

    child继承parent类,重写了类内的func方法,没有改变函数签名,只改变函数内部代码。

    重载

    重载是指不改变函数名,但改变函数的参数、参数个数、参数顺序。重载改变了函数的签名。

    • 两个同名函数要在同一个作用域下
    • 两个函数只有返回值不同,这是不允许的
    • 重载函数有默认参数的时候,语法上是可以通过的,但是调用函数可能会出现二义性,编译不允许。

    代码如下:

    #include <iostream>
    
    class parent
    {
    private:
    public:
        parent(){};
        virtual void func(){
            std::cout << 123 << std::endl;
        }
    
    };
    
    class child : parent{
    public:
        void func(int a){
            std::cout << 456 << std::endl;
        }
    
    };
    
    int main(int argc, char const *argv[])
    {
        child a;
        a.func(12);
        return 0;
    }
    

    child继承parent类,重载了类内的func方法,改变了函数签名(增加了一个参数),方法内部代码可以改变也可以不改变,但是不改变。

    展开全文
  • 代码重构的常用方法(C++实现)

    千次阅读 多人点赞 2019-11-06 23:27:34
    代码重构的常用方法 (C++实现) 重构是在软件开发中改善已有代码的一种方法,通过代码重构可以改进软件的设计、使得软件更容易理解、有利于Bug的发现以及提高后续开发效率。Martin Fowler在《重构:改善既有代码的...
  • Visual Studio用来重构C++代码的工具 VS 提供了重构C++的工具,官方文档: 《在 Visual Studio 中编辑和重构 C++ 代码 | Microsoft Docs》
  • 书名:重构改善既有代码的设计 作者:Martin Fowler 翻译:熊节 出版社:人民邮电出版社 软件开发的不朽经但,生动阐述重构原理和具体做法。
  • C++知识点,学习c++

    2014-08-28 17:45:13
    一、#include “filename.h”和#include 的区别 #include “filename.h”是指编译器将从当前工作目录上开始查找此文件 #include 是指编译器将从标准库目录中开始查找此文件 二、头文件的作用 ...
  • 1.3.重构原则: 正常流程在最外层,保持主干流程是正常核心流程; 避免嵌套过深;减少if语句数目;异常条件先退; 1.4.实现手段: 减少嵌套、移除临时变量、条件取反判断、合并条件表达式等(减少或优化if语句) ...
  • #include<vector> using namespace std; int main() { vector<int> vec = { 1,2,3,4 }; vec.push_back(5); # 在尾部进行元素插入操作 return 0; }
  • C++系列文章 【C++学习】C++ 中...C++对类的重构,首先要对C++的数据结构,代码结构,封装继承虚函数等的使用要有基础,其次要对已有代码有充分的了解和认知,最后是掌握一定的重构技巧和方法。 重构时需要有一定的
  • 在上一篇文章——重构,第一个案例(C++版)——最初的程序,我们已经实现了一个影片出租程序的最初版本。我们也分析了,这个版本的程序虽然能跑起来,没有bug。但是,明显的,程序中有一些“代码的坏味道”。为了...
  • 如何实施重构  稍微复杂的重构,基本都是由一系列的重构手法组成. 《重构》一书中针对各种重构场景,给出了大量的重构手法.这些手法有的复杂,有的简单,如果不加以系统化的整理和提炼,很容易迷失在细节中.  ...
  • C++学习之函数重构

    2018-05-06 19:48:28
    C++是C语言的延伸,我们学习可以对比着学习。函数重载我们可以类比于生活中一些事情,比如:看这个动词,我们可以看书、看鸟、看电视,看这个词可以和很多名词进行搭配,看这个动词可以类比于函数名,和它搭配的值...
  • C++重构工具比较

    千次阅读 2007-01-17 10:02:00
    比较好的C++重构工具:一:SlickEdit, 它的重构功能比较完美,不过,它直接使用跟Visual Stuido.Net 的工程,还不知道是什么原因,会有问题,不能重构VS工程里的代码。二:Ref++, 它可很好地集成到Visual Studio.Net...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,382
精华内容 19,352
关键字:

c++重构

c++ 订阅