首页 > 编程 > C++ > 正文

C++最好不要做以下几点

2020-02-24 14:37:15
字体:
来源:转载
供稿:网友

C++最好不要做以下几点,有些同学可能上过C语言课程,喜欢学习C的,喜欢将所有的变量定义放在开头,但是在C++中,我建议最好不要这样做,整理如下,主要是方便刚开始接触c++的朋友,下面一起来进一步了解其中的详情吧。

1、最好不要使用引用返回值

有同学在传递的参数的时候使用引用方式传递,避免了临时对象的创建,提高了效率,那么在返回值的时候能不能使用引用呢?

看如下代码


        class Rational{
        public:
            Raional( int numerator = 0, int denominator =1);
            ...
        private:
            int d, d;
            friend Rational operator* (const Rational& lhs, const Raional& rhs) ;
        };
       Rational Rational::operator* (const Rational& lhs,const Raionl&rhs)
        {
                return Rational  result(lhs.n*rhs.n,lhs.d*rhs.d);
        }
    }  

   
    这个类就是我们前面所介绍的有理数类。这里想想会发生一次类的构造与类的析构,那么如果使用引用就可以避免这个问题吗?达到提高效率吗?

 

函数创建新对象有两种方法,一个是在栈(statck)中创建,一个是在堆(heep)中创建。


        People p(a,b)                  //栈中创建
        People *p = new People(a,b)   //堆中创建

 
 现在首先考虑在栈中创建,但是这个创建的变量是一个局部变量,会在退出函数之前销毁。


   const Rational& operator* (const Rational& lhs, const Rational & rhs)
        {
            Rational  result(lhs.n*rhs.n,lhs.d*rhs.d);
            return result;
        }  


 在函数内以stack方式空间创建对象是局部对象,任何函数如果返回一个引用指向某个局部对象,都会发生错误。因为局部对象在函数退出之前被销毁了,意味着reference所指的对象不存在。
      于是考虑在堆中创建

 

 


const Rational& operator* (const Rational& lhs, const Rational & rhs)
        {
            Rational*  result=new Rational(lhs.n*rhs.n,lhs.d*rhs.d);
            return *result;
        } 

 
 现在又发现了一个问题,new出来的对象由谁来delete?好这个问题先占时不考虑看下面情况


          Rational w,x,y,z;
          w=x*y*z;      

  
   这里同时一个语句调用了两次operator*,意味着new了两次,也就需要delete两次。但是这里没有合理的办法让opertaor*使用者进行那些delete调用,因为无法让使用者获取返回的指针,这将导致资源泄漏。
      于是考虑返回一个引用,其指向定义于函数内部的static Rational对象。


const Rational & operator*(const Rational& lhs,const Rational & rhs)
        {
            static Rational result;
            result = ...;
            return result;
        }

 
 那么显而易见就是多线程,在多线程环境下,这样写安全吗?好如果说不关多线程。那么如下代码会发生什么?


  bool operator == (const Rational& lhs, const Rational&  rhs);
    ...
    Raional a,b,c,d;
    if((a*b) == (c*d)
    {
            ...
    }   

   
    上述if语句表达式无论a,b,c,d为何值都是true,因为它们都指向同一个静态值。

 

2、最好不要将所有变量定义放在语句开头。

有同学可能上过C语言课程,喜欢学习C的,喜欢将所有的变量定义放在开头,但是在C++中,我建议最好不要这样做,因为定义一个变量时,程序便注定需要进行一次构造与析构。例如在下面程序:大概意思我们允许1米8以下并且年龄在60岁以下的同学买票进入。


 class People{...};
 class Ticket{...};
 bool Isvalid(const People&p){...}
 void Banding(const People& p,Ticket& t);
 Ticket buyTicket(const People& p)
 {
     Ticket t;
     if(Isvalid(p)){ return NULL };
     //信息与票绑定
    Banding(p,&t);
    return t;
}


假如这里检测买票人条件不符合,那么就不能进入买票从而进行信息与绑定操作,那么这里Ticket t语句就让该函数白白承受了一次Ticket构造成本与析构的成本。
所以最好不要将变量提前定义,最好在要用到的时候定义,避免不必要的性能开销。上面例子改成下面这样即可:

 

 

 

 


 class People{...};
 class Ticket{...};
 bool Isvalid(const People&p){...}
 void Banding(const People& p,Ticket& t);
 Ticket buyTicket(const People& p)
 {
     if(Isvalid(p)){ return NULL };
     Ticket t;
     //信息与票绑定
     Banding(p,&t);
     return t;
 }

 

 

 

 

 

3、最好不要做过多的类型转换

C++规则的设计目标之一是,保证“类型错误”绝不可能发生。理论上程序通过编译,就表示它并不企图在任何身上执行任何不安全,荒谬的操作。可惜类型转换破环了类型系统,它可能导致任何种类麻烦,有些非常麻烦。就例如本文最后一个代码例子。C和C++都支持隐形类型转换,同时C++有四种显示转换操作符。成员函数与非成员函数的抉择里有介绍。但是建议最好不要做过多的类型转换,能避免就避免。类型转换往往也不是按照你的意思,首先看一个例子:


 #include
 class base
 {
     public:
         base():a(0),b(0){}
         base(const int& x,const int& y)
         :a(x),b(y){}
         virtual void init()
        {
            a=5;
            b=5;
            std::cout             std::cout         }

        int get_a() const
        {
            return a;
        }

        int get_b() const
        {
            return b;
        }
    private:
        int a;
        int b;
};

 

class derived:public base
{
    public:
        derived(int x,int y):base(x,y){}
        void init()
        {
            static_cast

(*this).init();
        }
};


运行结果为
in base a value is 5
in base b value is 5
a value is 2
b value is 2

 

 

 

 

 

这里将derived类型转化为base,但是调用base::init()函数并不是当前对象上的函数,而是早前转型动作所建立的一个"*this对象的base的副本,所以当我们尝试改变对象内容,其实改变的是副本内容,其对象内容并没有被改变。

如何解决这个问题呢?我们可以直接声明调用基类的函数


class derived:public base
{
    public:
        derived(int x,int y):base(x,y){}
        void init()
        {
            //static_cast

(*this).init();
            base::init();
        }
};


运行结果为:
in base a value is 5
in base b value is 5
a value is 5
b value is 5

 

或许此时你记起来应该使用dynamic_case(如果看过以前的文章的话:它用于安全地沿着继承关系向下进行类型转换)。使用dynamic_cast直接出现错误。

 


 class derived:public base
 {
     public:
         derived(int x,int y):base(x,y){}
         void init()
         {
             //static_cast

(*this).init();
             //base::init();
             dynamic_cast

(this)->init();
         }
 };

 

运行结果为:

段错误 ((主存储器)信息转储)假设一个类有五层的单继承关系,如果在该对象上执行dynaic_cast,那么会有多达五次的strcmp调用,深度或者多重继承的越多,成本越高。之所以需要dynamic_cast是因为想在derived class对象上执行 derived class操作函数,但是目前只有一个指向base的指针或者引用,这个时候可以用它们来处理。

C++最好不要做以下几点就为大家介绍到这,希望你们能够注意运用,更多精彩内容,尽在https://js.Vevb.com。

发表评论 共有条评论
用户名: 密码:
验证码: 匿名发表