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() << '\n';
}

结果例如以下:

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3Vvb2w=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="">

相同能够在全部函数之外声明变量,由于他不属于不论什么的函数或者块之内,所以不是自己主动类型,并且其内存也必须为静态类型的,但对于这样的变量不须要加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() << '\n';
}

和自己主动类型不一样的是,对于没有初始化序列的静态变量,不管是否为内置类型,均会被填充为零,假设类型为类且该类有自己定义的构造函数,则会调用该类的默认构造函数进行初始化.使用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() << '\n';
}

内联函数

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

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

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

内联函数的缺点:

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

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

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

这些规则被称为ＯＤＲ规则（One-Defination Rule）.

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

NEXT

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

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