都说学好C++需具备很多条件？今天说说学C++你最好不要做的几点！

只看了一本 C++ 入门书，然后就高高兴兴开始写代码做项目，你会发现（或者别人早于你发现）你的代码写得像屎一样。并且，这坨代码看似跑得很好，但某天可能突然给你来一个原地爆炸。哈哈哈，今天小编还是给大家来点干货吧！

 

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

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

下面是小编整理的一套c++系统学习资料，加小编C/C++编程学习qq群：825414254获取！

 

看如下代码

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 <iostream> 
 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<<"in base a value is "<<a<<std::endl;
 std::cout<<"in base b value is "<<b<<std::endl;
 }
 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<base>(*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<base>(*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<base>(*this).init();
 //base::init();
 dynamic_cast<base*>(this)->init();
 }
 };

运行结果为：

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