zoukankan      html  css  js  c++  java
  • C++基础学习教程(八)

    转载请注明出处:http://blog.csdn.net/suool/article/details/38300117

    引入

    在进行下一步的学习之前,我们须要厘清几个概念.

    RAII

    首先介绍一个编程习语,”RAII”(ResourceAcquisition Is Initialization,资源获取即为初始化),他描写叙述了利用构造函数析构函数,并在函数返回时自己主动析构的机制.简言之,RAII意为构造函数获取一种资源;打开一个文件,一个网络连接,或不过从某I/O流中复制一些标志.这样的获取是对象初始化的一部分,而析构函数则释放该资源:关闭文件,断开网络连接,或者恢复I/O流中全部被改动的标志.

    仅仅要定义了某RAII类的对象,就能够使用该类,编译器会完毕余下的相关工作.RAII类的构造函数通过他所须要的全部參数来获取资源.当某个RAII对象锁所在的函数返回的时,该对象会自己主动析构并释放资源,That is it.

    有时候甚至不须要等到函数返回,在一条复合语句中定义了一个RAII对象,则该语句结束,控制流离开复合语句时,该对象即被析构.

    以下举例:代码要实现的是:


    /** @file RAII.cpp */
    /** The color Class */
    class color
    {
    public:
      color() : red_(0), green_(0), blue_(0) {}
      color(int r, int g, int b) : red_(r), green_(g), blue_(b) {}
      int red() const { return red_; }
      int green() const { return green_; }
      int blue() const { return blue_; }
      /// Because red(), green(), and blue() are supposed to be in the range [0,255],
      /// it should be possible to add them together in a single long integer.
      /// TODO: handle errors if any color component is out of range
      long int combined() const { return ((red() * 256L + green()) * 256) + blue(); }
    private:
      int red_, green_, blue_;
    };
    
    inline bool operator==(color const& a, color const& b)
    {
      return a.combined() == b.combined();
    }
    
    inline bool operator!=(color const& a, color const& b)
    {
      return not (a == b);
    }
    
    inline bool order_color(color const& a, color const& b)
    {
      return a.combined() < b.combined();
    }
    
    /// Write a color in HTML format: #RRGGBB.
    std::ostream& operator<<(std::ostream& out, color const& c)
    {
      std::ostringstream tmp;
      // The hex manipulator tells a stream to write or read in hexadecimal (base 16).
      tmp << '#' << std::hex << std::setw(6) << std::setfill('0') << c.combined();
      out << tmp.str();
      return out;
    }
    
    class ioflags
    {
    public:
      /// Save the formatting flags from @p stream.
      ioflags(std::basic_ios<char>& stream) : stream_(stream), flags_(stream.flags()) {}
      /// Restore the formatting flags.
      ~ioflags() { stream_.flags(flags_); }
    private:
      std::basic_ios<char>& stream_;
      std::ios_base::fmtflags flags_;
    };
    
    std::istream& operator>>(std::istream& in, color& c)
    {
      ioflags flags(in);
    
      char hash;
      if (not (in >> hash))
        return in;
      if (hash != '#')
      {
        // malformed color: no leading # character
        in.unget();                 // return the character to the input stream
        in.setstate(in.failbit);    // set the failure state
        return in;
      }
      // Read the color number, which is hexadecimal: RRGGBB.
      int combined;
      in >> std::hex >> std::noskipws;
      if (not (in >> combined))
        return in;
      // Extract the R, G, and B bytes.
      int red, green, blue;
      blue = combined % 256;
      combined = combined / 256;
      green = combined % 256;
      combined = combined / 256;
      red = combined % 256;
    
      // Assign to c only after successfully reading all the color components.
      c = color(red, green, blue);
    
      return in;
    }
    

    当中上面的这段代码的ioflags就是RAII对象:



    它包括的内容有:

    • l  std::basic_ios<char>是全部的如istream和ostream的演示样例.ioflags对于输入流和输出流都能够工作.
    • l  std::ios_base::fmtflags类型是全部格式化标志的类型.
    • l  无參数函数flags()返回当前全部格式化的标准.
    • l  单參数成员函数flags()将全部的格式化标志都设置给该參数.

    Ioflags的用法是在一个函数或者复合语句中定义一个ioflags的类型变量,并将一个流对象作为唯一的參数传递给ioflags的构造函数.则该函数能够随意改动流的标志.本例中,输入操作符函数使用hex操作子将输入进制改动为十六进制.格式化标志存储了输入进制.操作符函数还关闭了skipws标志.该标志关闭则表示输入操作符不再同意井号(#)和颜色值之间有不论什么的空白符.

    当输入函数返回时,ioflags对象被析构,析构函数恢复原先的格式化标志.假设不适用RAII技术,则>>操作符函数就须要在全部的四个返回点手动恢复标志.

    声明和定义

    下一个厘清的概念是函数声明和定义,这个在之前讲过



    如以下的代码:

    /** @file def_cl.cpp */
    /** Declarations and Definitions of Member Functions */
    class rational
    {
    public:
      rational();
      rational(int num);
      rational(int num, int den);
      void assign(int num, int den);
      int numerator() const;
      int denominator() const;
      rational& operator=(int num);
    private:
      void reduce();
      int numerator_;
      int denominator_;
    };
    
    rational::rational()
    : numerator_(0), denominator_(1)
    {}
    
    rational::rational(int num)
    : numerator_(num), denominator_(1)
    {}
    
    rational::rational(int num, int den)
    : numerator_(num), denominator_(den)
    {
      reduce();
    }
    
    void rational::assign(int num, int den)
    {
      numerator_ = num;
      denominator_ = den;
      reduce();
    }
    
    void rational::reduce()
    {
      assert(denominator_ != 0);
      if (denominator_ < 0)
      {
        denominator_ = -denominator_;
        numerator_ = -numerator_;
      }
      int div(gcd(numerator_, denominator_));
      numerator_ = numerator_ / div;
      denominator_ = denominator_ / div;
    }
    
    int rational::numerator()
    const
    {
      return numerator_;
    }
    
    int rational::denominator()
    const
    {
      return denominator_;
    }
    
    rational& rational::operator=(int num)
    {
      numerator_ = num;
      denominator_ = 1;
      return *this;
    }
    

    由于每一个函数名字都由类名字開始,所以构造函数完整的名字是rational::rational,成员函数的名字形式都如rational::numerator, rational::operator =等到.C++把这样的完整形式的名字称为限定名.

    内联函数

    在前面的解说中我们说过一个函数内联函数”inline”,它提示编译器在函数的调用点以空间换时间.也能够将inline适用于成员函数上.其实,假设一个函数只返回一个数据成员而不作其他的事情话,则内联函数会提快速度,同一时候添加了程序的大小.



    /** @file inline.cpp */
    /** The rational Class with inline Member Functions */
    class rational
    {
    public:
      rational(int num) : numerator_(num), denominator_(1) {}
      inline rational(int num, int den);
      void assign(int num, int den);
      int numerator() const                   { return numerator_; }
      int denominator() const                 { return denominator_; }
      rational& operator=(int num);
    private:
      void reduce();
      int numerator_;
      int denominator_;
    };
    
    inline rational::rational(int num, int den)
    : numerator_(num), denominator_(den)
    {
      reduce();
    }
    
    void rational::assign(int num, int den)
    {
      numerator_ = num;
      denominator_ = den;
      reduce();
    }
    
    void rational::reduce()
    {
      assert(denominator_ != 0);
      if (denominator_ < 0)
      {
        denominator_ = -denominator_;
        numerator_ = -numerator_;
      }
      int div(gcd(numerator_, denominator_));
      numerator_ = numerator_ / div;
      denominator_ = denominator_ / div;
    }
    
    rational& rational::operator=(int num)
    {
      numerator_ = num;
      denominator_ = 1;
      return *this;
    }
    


    静态变量

    以下要说的是静态变量.

    局部变量是自己主动类型的,即当进入一个函数或者局部块的时再分配内存构造对象,而当函数返回或者控制离开块的时则析构对象并释放内存.由于全部的自己主动类型变量都是在栈上分配的,所以不必关心内存的分配和释放,这些工作由主机平台的正常的函数调用指令来完毕.

    同一时候main()函数也一样,在当中定义的变量也是自己主动类型的变量,在栈上分配空间.自己主动类型变量的行为遵循RAII等原则,这极大简化了一般的编程任务,可是不是全部的,有时候须要一个变量生命周期贯穿各个函数调用..

    比方:假设一个函数要为一些对象生成唯一的身份编号,号码从1開始,并依次递增计数器.那么该函数就须要记录计数器的值,在函数返回之后也需如此.例如以下的代码片段:

    /** Generating Unique Identification Numbers */
    int generate_id()
    {
      static int counter(0);
      ++counter;
      return counter;
    }
    

    keywordstatic告诉编译器该变量不是自己主动类型,而是静态类型.变量counter会在generate_id()被首次调用的时候进行初始化,其内存既不是自己主动类型,也不分配在程序栈上.全部的静态变量会分配在一个长久保留的地方.因而当generate_id()返回的时候,counter将保持原有值而不会丢失.

    编写一个程序并多次调用generate_id(),观察是否在每次调用的时候生成新的值.代码例如以下:


    /** Calling generate_id to Demonstrate Static Variables */
    #include <iostream>
    #include <ostream>
    
    int generate_id()
    {
      static int counter(0);
      ++counter;
      return counter;
    }
    
    int main()
    {
      for (int i = 0; i != 10; ++i)
        std::cout << generate_id() << '
    ';
    }
    

    结果例如以下:



    相同能够在全部函数之外声明变量,由于他不属于不论什么的函数或者块之内,所以不是自己主动类型,并且其内存也必须为静态类型的,但对于这样的变量不须要加statickeyword.例如以下:你也许会想到全局变量,也能够这么称呼,可是这不是C++的标准术语.

    /** Declaring counter Outside of the generate_id Function */
    #include <iostream>
    #include <ostream>
    
    int counter;
    
    int generate_id()
    {
      ++counter;
      return counter;
    }
    
    int main()
    {
      for (int i = 0; i != 10; ++i)
        std::cout << generate_id() << '
    ';
    }
    

    和自己主动类型不一样的是,对于没有初始化序列的静态变量,不管是否为内置类型,均会被填充为零,假设类型为类且该类有自己定义的构造函数,则会调用该类的默认构造函数进行初始化.使用C++静态变量的一个困难在于,程序难以控制他们的初始化时间.c++标准提供两个保证:

    • l  静态对象依照源文件里出现的次序依次进行初始化
    • l  静态对象会被在main()使用之前进行初始化,或者在main()调用不论什么函数前进行初始化.

    静态数据成员

    keywordstatic有很多用途.在累的某成员声明之前使用static则将其声明为一个静态数据成员.静态数据成员不属于不论什么的该类的对象,而是独立于他们的存在.该类的全部的对象共享一份该数据成员实例.

    由于静态数据成员不是对象的一部分,因此不要将它写在构造函数的初始化器的类表中,正确的方法是像对待普通的全局变量那样来初始化静态数据成员,且勿忘记在成员名之前加上类名.以下一个演示样例:


    /** Using Static Data Members for an ID Generator */
    #include <iostream>
    #include <ostream>
    
    class generate_id
    {
    public:
      generate_id() : counter_(0) {}
      long next();
    private:
      short counter_;
      static short prefix_;
      // The counter rolls over at a fairly low value (32,767), to ensure the code
      // is completely portable to all systems. Real code can use a higher value
      // before rolling over, but that involves C++ features that the book has not
      // yet covered.
      static long int const max_counter_ = 32767;
    };
    
    // Switch to random-number as the initial prefix for production code.
    // short generate_id::prefix_(static_cast<short>(std::rand()));
    short generate_id::prefix_(1);
    long const generate_id::max_counter_;
    
    long generate_id::next()
    {
      if (counter_ == max_counter_)
        counter_ = 0;
      else
        ++counter_;
      return prefix_ * (max_counter_ + 1) + counter_;
    }
    
    int main()
    {
      generate_id gen;           // Create an ID generator
      for (int i = 0; i != 10; ++i)
        std::cout << gen.next() << '
    ';
    }
    

    内联函数

    内联函数,即是inline函数,通常的做法是在一个头文件里声明函数,然后在还有一个源文件里定义这些函数并链接到程序中.大多数成员函数的都与类分开.

    但内联函数的规则和普通函数不同.调用内联函数的源文件还须要该函数的定义.而在每一个使用内联函数的源文件总,该内联函数的定义不能多于一个,且在整个程序中,该函数的定义也必须同样.

    写在头文件的函数的规则:头文件包括了非内联函数的声明和内联函数的定义.分开的源文件包仅定义非内联函数.

    内联函数的缺点:

    • l  添加编译时间
    • l  添加重编译

    因此在实际的编程中,把函数声明和定义分离开更加明智.

    一份定义规则:编译器有一个规则就是,同意每一个源文件里有一份类函数对象的定义.还有一个规则是函数或全局对象的定义,能够在多个源文件里定义某个类,仅仅要该定义在全部的源文件里同样就可以.同一时候上面讲到的能够在多个源文件里定义内联函数,而每一个源文件仅能有一份该内联函数的定义,且该内联函数在程序中的每一个定义必须同样.

    这些规则被称为ODR规则(One-Defination Rule).

    编译器要求在每一个源文件总必须遵守ODR,可是多个源文件的错误仅仅能靠自己检查和注意,由于编译器不会检查多文件的ODR违例.



    NEXT

    一些算法迭代器异常基础知识.

  • 相关阅读:
    [LeetCode] 294. Flip Game II 翻转游戏之二
    [LeetCode] 293. Flip Game 翻转游戏
    [LeetCode] 266. Palindrome Permutation 回文全排列
    [LeetCode] 288. Unique Word Abbreviation 独特的单词缩写
    [LeetCode] Self Crossing 自交
    [LeetCode] 281. Zigzag Iterator 之字形迭代器
    [LeetCode] 251. Flatten 2D Vector 压平二维向量
    [LeetCode] 250. Count Univalue Subtrees 计数相同值子树的个数
    [LeetCode] 249. Group Shifted Strings 群组偏移字符串
    [LeetCode] 248. Strobogrammatic Number III 对称数之三
  • 原文地址:https://www.cnblogs.com/zfyouxi/p/5058923.html
Copyright © 2011-2022 走看看