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适用于成员函数上.事实上,如果一个函数仅仅返回一个数据成员而不作其它的事情话,则内联函数会提高速度,同时增加了程序的大小.

下面要说的是静态变量.

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

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

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

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

关键字static告诉编译器该变量不是自动类型,而是静态类型.变量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';
}

结果如下:

同样可以在所有函数之外声明变量,因为他不属于任何的函数或者块之内,所以不是自动类型,而且其内存也必须为静态类型的,但对于这种变量不需要加static关键字.如下:你或许会想到全局变量,也可以这么称呼,但是这不是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()调用任何函数前进行初始化.

静态数据成员

关键字static有许多用途.在累的某成员声明之前使用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