好久没有用c++,转一个c++注意点

一   编程设计
     1.将程序划分为多个子系统,包括子系统间的接口和依赖关系、子系统间的数据流、在各子系统间的来回输入输出、以及总的线程模型。

     2.各个子系统的具体细节,包括进一步细分的类、类层次体系、数据结构、算法、特定的线程模型和错误处理。

二   设计流程
     1.需求:功能需求和性能需求。
     2.设计步骤
       (1)把程序划分为通用功能子系统,并明确子系统的接口和交互。
       (2)把这些子系统列在一个表中,并表示出子系统的高层行为或功能、子系统向其它子系统提供的接口,及此子系统使用了其他子系统的哪些接口。
       (3)选择线程模型:确定使用多少个线程,明确线程的交互并为共享数据指定加锁机制。
       (4)为每个子系统指定层次体系
       (5)为每个子系统指定类、数据结构、算法和模式
       (6)为每个子系统指定错误处理(系统错误 + 用户错误),指定是否使用异常

三   C++ 的设计原则
     1.抽象:将接口与实现相分离
     2.重用:代码重用和思想重用

四   对象关系
     1.has-a 关系(聚集)
     2.is-a  关系(继承)
     3.组织对象层次体系:
      (1)将类按有意义的功能加以组织。
      (2)将共同的功能放到超类中,从而支持代码重用。
      (3)避免子类过多的覆盖父类的功能。

五   重用设计
     1.建立可重用的代码结构
      (1)避免将无关或逻辑上分离的概念混在一起
      (2)把程序划分为子系统
      (3)使用类层次体系来分离逻辑概念
      (4)使用聚集来分离逻辑概念
      (5)对通用数据结构和算法使用模板
      (6)提供适当的检查和防护

六   设计易于使用的接口
     1.开发直观的接口
     2.不要遗漏必要的功能
     3.提供简洁的接口
      (1)消除重复的接口
      (2)只提供所需的功能
      (3)适当的限制库的使用
     4.提供文档和注释
      (1)公共的文档应指定行为,而不是底层实现

七   设计通用的接口
     1.提供多种方法来完成同一功能
     2.提供定制能力

八   协调一般性和通用性
     1.提供多个接口
     2.优化常用功能

九   代码注释
     (1)前缀注释
        * 文件/类名
        * 最后一次修改时间
        * 原作者
        * 文件所实现特性的编号 (特性 ID)
        * 版权信息
        * 文件/类的简要描述
        * 未完成的特性
        * 已知的 bug

     (2)注释示例
        /*
         * Watermelon.cpp
         *
         * $Id: Watermelon.cpp,v 1.6 2004/03/10 12:52:33 klep Exp $
         *
         * Implements the basic functionality of a watermelon. All
         * unit are expressed in terms of seeds per cubic centimeter
         * Watermelon theory is based on the white paper "Alogorthms
         * for Watermelon Processing."
         *
         * The following code is (c)copyright 2004. FruitSoft, Inc.
         * All right reserved
         */

十   编写代码
     1.类定义在 C++ 中是一条语句,因此必须以分号结束。
     2.:: 指作用域解析操作符。
     3.在栈和堆上使用对象的区别
       (1)在栈上创建对象
          SpreadsheetCell myCell, anotherCell;

       (2)在堆上使用对象
          SpreadsheetCell *myCellp = new SpreadsheetCell();

       (3)如果用 new 来分配一个对象,用完该对象时要用 delete 来释放

     4.C++ 程序员通常把构造函数称为 "ctor"

     5.使用构造函数
       (1)在栈上使用构造函数
          SpreadsheetCell myCell(5);

       (2)在堆上使用构造函数
          SpreadsheetCell *myCell = new SpreadsheetCell(5);
          delete myCell;

       (3)不要尝试从类的一个构造函数调用另一个构造函数

     6.使用默认构造函数
       (1)在栈上使用构造函数
          SpreadsheetCell myCell;  //right
          SpreadsheetCell myCell();//wrong

       (2)在栈上创建对象时,要去掉默认构造函数的小括号
       (3)在堆上使用默认构造函数
          SpreadsheetCell *myCellp = new SpreadsheetCell();

       (4)什么时候需要使用构造函数
          SpreadsheetCell cells[3];//fails comilation without default ctor
         SpreadsheetCell *myCellp = new SpreadsheetCell[10];//alse fails

       (5)使用初始化列表
          1)初始化列表允许在创建数据成员的同时完成数据成员的初始化
          2)使用初始化列表的情况

      数据成员                                         解释
      ------------------------------------------------------------------
      const 数据成员                              必须在创建时提供值
      引用数据成员                               引用无法独立存在
      没默认构造函数的对象成员       对象成员无法初始化
      没有默认构造函数的超类           见后面 
      ------------------------------------------------------------------

     7.对象的撤销
       (1)析构函数仅用于释放内存或释放其他资源是一个不错的想法

     8.浅复制深复制
       (1)浅复制:只是从源对象直接将数据成员复制或赋值到目标对象
       (2)深复制:非浅复制
       (3)只要在类中动态分配了内存,就应该编写自己的复制构造函数来提供内存的深复制
       (4)在对一个对象进行赋值前,必须先释放此对象的所有动态分配的内存
       (5)只要类会动态分配内存,就需要编写析构函数、复制构造函数、赋值操作符
       (6)禁止对象赋值,可将复制构造函数与赋值操作符声明为私有成员
       (7)不必为私有复制构造函数和赋值操作符提供实现,编译器不要求

十一 精通类和对象
     1.不能在静态方法中访问非静态数据成员
     2.保证一个对象不会修改数据成员,可用 const 来标记

     3.保证一个方法不会修改数据成员,可用 const 来标记
       (1)在类定义中的声明 double getValue() const;
       (2)在源文件中的实现
          double Spreadsheet::getValue() const
         {
            return this.mValue;
         }

     4.非 const 对象可以调用 const 和非 const 方法,const 对象只能调用const 方法

     5.应将所有不会修改对象的方法都声明为 const,并在程序中使用 const对象引用

     6.将变量置为 mutable,这样编译器允许在 const 方法中修改这个变量
     7.C++ 不允许仅基于方法的返回类型而重载一个方法名
     8.默认参数:从最右参数开始的连续参数表
     9.只能在方法声明中指定默认参数,在定义中并不指定
     10一个构造函数的所有参数都有默认值,此函数会作为默认构造函数
     11能利用默认参数做到的事情,利用方法重载也可以做,用你最熟悉的

     12内联:将方法体或函数体直接插入到代码调用处(相当于 #define 宏的安
       全版本),内联示例如下:

       (1)在类的源文件(SpreadsheetCell.cpp)
       inline double SpreadsheetCell::getValue() const
       {
           mNumAccess++;
           return mValue;
       }

       (2)或在类的声明文件中直接实现此方法而不用 inline 关键字
       //SpreadsheetCell.h
       double getValue() const (mNumAccesses++; return mValue;}

     13友元可以访问指定类中的 protected 和 private 数据成员和方法
       (1)声明友元类
          class SpreadsheetCell
          {
             public:
                 friend class Spreadsheet;
                //code omitted here
          };

       (2)声明友元方法
          class SpreadsheetCell
         {
             public:
                 friend bool checkSpreadsheetCell();
                 //code omitted here
         };


十二 C++ 中的继承机制
     1.超类指针(引用)在引用子类时,了类仍然会保留它们覆盖的方法。而在
       强制类型转换成超类对象时,子类会失去它们的独有特性。覆盖方法和子
       类数据的丢失称为切割。

     2.作为一条经验,要把所有的方法都用 virtual 声明 (包括析构函数,但
       是不包括构造函数) 来避免因遗漏关键字 virtual 而产生的相关问题

     3.virtual 用法示例:
       class Sub : public Super
       {
           public:
           Sub();
           virtual void someMethod();
           virtual void someOtherMethod();
       }

     4.要把所有的析构函数都用 virtual 声明

     5.强制类型转换
       (1)静态转换 static_cast<type>
          示例:
          Sub* mySub = static_cast<Sub*>(inSuper);

       (2)动态转换 dynamic_cast<type>
          示例:
          Sub* mySub = dynamic_cast<Sub*>(inSuper);
          if (mySub == NULL)
         {
              //proceed to access sub methods on mySub
         }
  
   注意:如果对指针不能进行动态类型转换,指针则为 NULL, 而不是指
   向无意义的数据。

     6.进行向上强制类型转换时,要使用指向超类的指针或引用来避免切割问题

     7.纯虚方法与抽象基类
       (1)纯虚方法: 在类定义中显示未定义的方法。
       (2)抽象类: 含有纯虚方法的类(不能实例化)。
       (3)纯虚方法语法定义: 在类定义中简单的设置方法等于 0,在 cpp 文件
          中不要编写其实现代码。
   示例:
   class SpreadsheetCell
   {
       public:
           SpreadsheetCell();
           virtual ~SpreadsheetCell();
           virtual void set(const std::string instring) = 0;
           virtual std::string getString() const = 0;
     };

     8.定制类型转换函数
       (1)double 类型转换成 string 类型
          #include <iostream>
          #include <sstream>
  
          double inValue;
          string myString;

          ostringstream ostr;
          ostr << inValue;
          myString = ostr.str();

       (2)string 类型转换成 double 类型
          #include <iostream>
          #include <sstream>
  
          double myDouble;
          string inString;
  
          istringStream istr(inString);
          istr >> myDouble;
         if (istr.fail())
        {
           myDouble = 0;
        }

     9.使用预编译指令避免重复包含头文件
       #ifndef _TEST_H_
       #define _TEST_H_
       // include header files here      
       // other code omitted here

       #endif
  
十三 覆盖方法的特殊情况
     1.在 C++ 中不能覆盖静态方法。
       (1)不能同时用 virtual 和 static 声明一个方法。
       (2)在对象上可以调用 static 方法,但 static 方法只存在于类中。

十四 利用模板编写通用代码
     1.模板相关概念
       (1)类模板: 存储对象的容器或数据结构。
       (2)模板的语法:
          template <typename T>
         class Grid
         {
             public:
                 Grid(int inWidth, int inHeight);
                 Grid(const Grid<T>& src);
                 Grid<T>& operator=(const Grid<T>& rhs);
                 T& getElementAt(int x, int y);
                 const T& getElementAt(int x, int y);
                 void setElementAt(int x, int y, const T& inElem);

             protected:
                 void copyFrom(const Grid<T>& src);
                 T** mCells;
        };
        (3)语法解释
            template <typename T> : 指在类型 T 上定义的模板。
            Grid<T> : Grid 实际上是模板名。
            Grid<T> : 将作为类模板中的类名。

 (4)模板定义(实现)
    template <typename T>
    Grid<T>::Grid(int inWidth, int inHeight)
    {
        mCells = new T* [mWidth];
        for (int i = 0; i < mWidth; i++)
        {
            mCells[i] = new T[mHeight];
        }
    }

 (5)模板实例化
    Grid<int> myIntGrid;

十五 C++ 中的一些疑难问题
     1.引用
       (1)定义: 另一个变量的别名, 对引用的修改会改变其所指向的变量。
       (2)引用变量必须在创建时就初始化。
          int  x = 3;   // right
          int& xRef = x;// right
          int& emptyRef;//wrong
          注: 类的引用数据成员可在构造函数的初始化列表中初始化。

       (3)不能创建指向未命名值的引用(const 常量值除外)
          int& unnameRef = 5;      //does not compile
          const int& unnameRef = 5;//works as expect

       (4)修改引用: 引用总是指向初始化时指定的那个变量。
          int x = 3, y = 4;
          int& xRef = x;
          xRef = y; // change x value to 4, doesn't make refer to y;
          xRef = &y; // doesn't compile, type not match
         注: 引用指向的变量在初始化之后不能再改变, 只能改变此变量的值

       (5)指针引用和引用指针
          //指针引用示例(指向指针的引用)
          int*  intP;
          int*& ptrRef = intP;
          ptrRef = new int;
         *ptrRef = 5;

         注:不能声明指向引用的引用, 也不能声明引用指针(指向引用的指针)
         int x = 3;
         int& xRef = x;
         int&& xDoubleRef = xRef; // not compile
         int&* refPtr = &xRef; // not compile
  
       (6)传引用vs传值
          1)效率。复制大对象和结构要花费很长时间。
          2)正确性。不是所有的对象都允许传值或正确的支持深复制
          3)不想修改原对象,又利用以上两优点,可在参数前加 const。
         4)对简单内置类型(如int或double)要传值,其它所有情况可传引用。

       (7)引用vs指针
          1)引用让程序清晰,易于理解。
          2)引用比指针安全,不存在无效的引用,不需要明确解除引用。
          3)除非需要动态分配内存或在其它地方要改变或释放指针指向的值,否则都应使用引用而非指针。
    
     2.疑难字 const
       (1)const 变量
          使用 const 来声明变量,对不能对其修改,以保护变量。

       (2)const 指针
       //不能改变指针指向的值
          const int* ip;
          ip = new int[10];
          ip[4] = 5; // not compile
        或
          int const* ip;
          ip = new int[10];
          ip[4] = 5; // not compile
 
          //不能改变指针自身
          int* const ip;
          ip = new int[10]; // not compile
          ip[4] = 5;

         //既不能改变指针也不能改变指针指向的值
         const int* const ip = NULL;(无用的指针)
          注: const 可以放在类型前也可以放在类型后
  
       (3)const 应用规则
          const 应用于其左则的第一项。

       (4)把对象参数传递时,默认的做法是把传递 const 引用。

       (5)const 方法
          用 const 标识类方法,可以防止方法修改类中不可变的数据成员。

     3.关键字 static
       (1)关于连接: C++ 中的每个源文件是独立编译的,得到的对象连接在一
          起。

       (2)外部连接: 一个源文件中每个名字(如函数或全局变量)对其它源文件
          是可用的。

       (3)内部连接: 一个源文件中每个名字(如函数或全局变量)对其它源文件
          是不可用的。内部连接也叫静态连接。

       (4)函数和全局变量默认是外部连接。

       (5)声明前加 static 可指定为内部连接。

     4.关键字 extern
       (1)作用: 与 static 相对,用来为位于它前面的名字声明外部连接。
       (2)extern 用法
          // AnotherFile.cpp
         extern int x; // 只是声明 x 为外部连接而不分配内存
         int x = 3;    //显示定义以分配内存
        或
          extern int x = 3;//声明和定义一起完成

          //FirstFile.cpp
         extern int x;
         cout << x << endl;

      5.强制类型转换
      (1)const_cast<type> 去除变量的常量性。
      示例:
      void g(char* str)
      {
          // body omitted here
      }
      void f(const char* str)
      {
          g(const_cast<char*>(str));
          // other code omitted here
      }      

 (2)static_cast<type> 显示的完成 C++ 语言支持的转换。
    示例:
    int x = 3;
    double result = static_cast<double>(i) /10;

    注: static_cast 进行类型转换时并不完成运行时类型检查。

 (3)dynamic_cast<type>
    1)对类型强制转换完成运行时类型检查。
    2)对指针转换失败时会返回 NULL。
    3)对引用转换失败时会抛出 bad_cast 异常。

 
6.函数指针
        (1)定义: 把函数地址作为参数,可以像变量一样使用。
        (2)定义函数指针: typedef bool(*YesNoFcn) (int, int);
        (3)用法示例

           //定义函数指针类型
           typedef string(*YesNoFcn)(int, int);

           void test(int value1, int values2, YesNoFcn isFunction)
          {
             cout << isFunction(value1, value2);
          }

         string intEqual(int intItem1, int intItem2)
         {
            return (intItem1 == intItem2) ? "match" : "not match";
         }

         //使用函数指针
          test(1, 1, &intEqual);

         注: & 是可选的


十六 C++ 中的 I/O 操作
     1.使用流
       (1)每个输入流都有一个相关联的源,每个输出流都有一个相关联的目的。

       (2)cout 和 cin 都是在 C++ 的 std 命名空间中预定义的流实例。

       (3)流的三种类型:
          1)控制台输入输出流。
          2)文件流。
          3)字符串流。

       (4)输出流
          1)输出流在头文件 <ostream> 中定义,输入流在 <istream> 中定义<iosream> 中定义了输入输出流。

          2)cout 和 cin 指控制台输入输出流。

          3)<< 操作符是使用输出流的最简单的方法。

          4)流其它的输出方法
             1)put() 和 wirte()
             2)flush() 刷新输出
 
          5)处理输出错误
             1)cout.good()  流是否处于正常的可用状态。
             2)cout.bad()   流输出是否发生了错误。
             3)cout.fail()  如果最近的操作失败则返回 true
             4)cout.clear() 重置流的错误状态

   6)输出控制符
     1)endl         输出回车并刷新其缓冲区
     2)hex oct dec  以十六/八/十进制输出
     3)setw         设置输出数值数据时的字段占位符
     4)setfill    设置填充空位的占位符

       (5)输入流
          1)>> 输入流操作符
          2)输入方法
              1)get()    仅仅返回流中的下一个字符
              2)unget()    引起流回退一个位置
              3)peek()    预览下一个值
              4)getline()    从输入流中取一行数据

          3)处理输入错误
             1)good()
             2)eof()

       (6)字符串流
          1)<ssteam>    定义了字符串流的头文件
         2)ostringstream  字符串输出流
         3)istringstream  字符串输入流

       (7)文件流
          1)<fstream>      定义了文件流的头文件
          2)ifstream    文件输入流
          3)ofstream    文件输出流
          4)seek()    定位流的位置
          5)tell()    查询流当前的位置

       (8)链接流
          1)定义: 在任何输入流与输出流之间建立连接,一旦访问就刷新输出。
          2)实现: 用输入流的 tie() 方法
          3)示例
            #include <iostream>
           #inlcude <fstream>
           #include <string>

           main()
           {           
                ifstream inFile("input.txt");
               ofstream outFile("output.txt");
    
                //set up a link between inFile and outFile.
                inFile.tie(&outFile);

               string nextToken;
               inFile >> nextToken;
         }


十七 C++ 中的异常
     1.抛出和捕获异常
       (1)<exception> 定义异常类的头文件。
       (2)抛出异常对象 throw exception()
       (3)向量的使用(整型)
        vector<int> myInts;
        for (int i = 0; i < 10; i++)
        {
             myInts.push_back(i);// 增加元素
             cout << myInts[i];
        }

       (4)string 风格的字符串转换成 C 风格的字符串
          string myString = "string style string";
          char* cStyleStrng = myString.c_str();

       (5)捕获运行时异常
          try
         {
            ...
          }
          catch (const runtime_error& e)
         {
           ...
         }

       (6)抛出和捕获无效参数异常
          throw invalid_argument("");

         try
          {
            ...
          }
          catch (const invalid_argument& e)
          {
             ...
          }

         注: runtime_error 和 invalid_argument 定义在头文件<stdexcept> 中

       (7)匹配任何异常(...)
          try
          {
            // code omitted here
          }
          catch (...)
          {
            // code omitted
          }
         注: 不建议使用这种方式

       (8)使用抛出列表
          1)抛出列表: 一个函数或方法能抛出的异常列表
          2)必须为函数声明和实现都提供抛出列表
          3)没有抛出列表就可以抛出任何异常
         4)空的抛出列表不允许抛出任何异常

       (9)在覆盖方法中修改参数列表
          1)从列表中删除异常
          2)增加超类抛出列表中异常的子类
          3)不能完全删除抛出列表

       (10)显示异常消息
           可调用 exception 或子类的 what() 方法显示捕获到的异常消息
           示例:
           try
           {
               ...
           }
           catch (const exception& e)
           {
               cerr << e.what() << endl;
               exit(1);
           }
            
       (11)多态地捕获异常
           1)在多态地捕获异常时,要确保按引用捕获异常。如果按值捕获异常,就会遇到切割问题,丢失对象的信息。

           2)按引用捕获异常可以避免不必要的复制开销

       (12)如果异常处理不够仔细,就会导致内存和资源泄漏
           示例
           func ()
          {
            string str1;
            string* str2 = new string();
            throw exception();
            delete str2;     // 内存泄漏
          }

       (13)使用智能指针防止内存泄漏
           #include <memory> // 定义智能指针的头文件
           using namespace std;
           func ()
           {
               string str1;

               // 智能指针,不用自己手动释放
              auto_ptr<string> str2(new string("hello"));
              throw exception();
           }

       (14)处理内存分配错误
           1)new 和 new [] 分配内存失败默认抛出 bad_alloc 异常
           2)可用 try/catch 捕获异常处理内存分配失败
           3)示例:
             try
             {
                 ptr = new int[numInts];
             }
             catch (bad_alloc& e)
            {
              cerr << "Unable to alloc memory!" << endl;
              return ;
            }
         或
          1)用 new(nothrow) 在内存分配失败时返回 NULL 来处理
          2)示例:
             ptr = new(nothrow) int[numInts];
            if (ptr == NULL)
            {
               cerr << "Unable to alloc memory!" << endl;
               return;
            }
         或
           1)用 set_new_handler() 回调函数定制分配失败时的行为
           2)示例
              void myNewHandler()
             {
                cerr << "Unable to allocate memory!" << endl;
                abort(); // 终止程序 <cstdlib>
             }
            
             #include <new>
            #include <cstdlib>
            #include <iostream>
            using namespace std;
     
            int main(int argc, char** argv)
           {
               new_handler oldHandler = set_new_handler(myNewHandler);

              // code omitted here

             set_new_handler(oldHandler);
             return (0);
         }

原文地址:https://www.cnblogs.com/cloudseawang/p/1142299.html