a + b + c = 17， a - b ＝5,请用求出a,b,c的所有可能值？

分析：由题意可知：a的取值范围为0~17,b的取值范围为0~12,c的取值范围为0~17.

#include <stdio.h>

void main(){
  int a, b, c;
  int n = 0;
  for (  a = 0; a < 17; a ++ ){
    for(  b = 0; b < 12; b++ ) {
      for (  c = 0; c < 17; c++ ) {
        if ( (a + b + c) == 17 && (a - b) == 5 ) {
          n++;
          printf("%d %d %d\t",a,b,c);
          if ( !( n % 3 ) ) printf("\n");
        }
     
      }
    }
  }
  printf("\n共有 %d 组结果\n",n);
}

预定义的算术函数对象支持加减乘除求余和取反调用的操作符是与Type 相

关联的实例对一个class 类型如果它提供了该操作符的重载实例则调用该实例

加法plus<Types>

plus<string> stringAdd;

// 调用 string::operator+()

sres = stringAdd( sval1, sval2 );

dres = BinaryFunc( plus<double>(), dval1, dval2 );

减法minus<Type>

minus<int> intSub;

ires = intSub( ival1, ival2 );

dres = BinaryFunc( minus<double>(), dval1, dval2 );

乘法multiplies<Type>

multiplies<complex> complexMultiplies;

cres = complexMultiplies( cval1, cval2 );

dres = BinaryFunc( multiplies<double>(), dval1, dval2 );

除法divides<Type>

divides<int> intDivides;

ires = intDivides( ival1, ival2 );

dres = BinaryFunc( divides<double>(), dval1, dval2 );

求余modulus<Type>

modulus<int> IntModulus;

Ires = IntModulus( Ival1, Ival2 );

ires = BinaryFunc( modulus<int>(), ival2, ival1 );

取反negate<Type>

negate<int> intNegate;

ires = intNegate( ires );

Ires = UnaryFunc( negate<int>(), Ival1 );

关系函数对象

预定义的关系函数对象支持等于不等于大于大于等于小于和小于等于

等于equal_to<Type>

equal_to<string> stringEqual;

sres = stringEqual( sval1, sval2 );

ires = count_if( svec.begin(), svec.end(),

equal_to<string>(), sval1 );

不等于not_equal_to<Type>

not_equal_to<complex> complexNotEqual;

cres = complexNotEqual( cval1, cval2 );

ires = count_if( svec.begin(), svec.end(),

not_equal_to<string>(), sval1 );

大于greater<Type>

greater<int> intGreater;

ires = intGreater( ival1, ival2 );

ires = count_if( svec.begin(), svec.end(),

greater<string>(), sval1 );

大于等于greater_equal<Type>

greater_equal<double> doubleGreaterEqual;

dres = doubleGreaterEqual( dval1, dval2 );

ires = count_if( svec.begin(), svec.end(),

greater_equal<string>(), sval1 );

小于less<Type>

less<int> IntLess;

Ires = IntLess( Ival1, Ival2 );

ires = count_if( svec.begin(), svec.end(),

less<string>(), sval1 );

小于等于less_equal<Type>

less_equal<int> intLessEqual;

ires = intLessEqual( ival1, ival2 );

ires = count_if( svec.begin(), svec.end(),

less_equal<string>(), sval1 );

逻辑函数对象

预定义的逻辑函数对象支持逻辑与两个操作数都为true 时结果值为true——应用与

Type 相关联的&& 逻辑或两个操作数中有一个为true 返回true——应用与Type 相关联

的|| 和逻辑非操作数为false 则返回true——应用与Type 相关联的!操作符

逻辑与logical_and<Type>

logical_and<int> intAnd;

ires = intAnd( ival1, ival2 );

dres = BinaryFunc( logical_and<double>(), dval1, dval2 );

逻辑或logical_or<Type>

logical_or<int> intSub;

ires = intSub( ival1, ival2 );

dres = BinaryFunc( logical_or<double>(), dval1, dval2 );

逻辑非 logical_not<Type>

logical_not<int> IntNot;

Ires = IntNot( Ival1, Ival2 );

dres = UnaryFunc( logical_not<double>(), dval1 );

函数对象的函数适配器

标准库还提供了一组函数适配器用来特殊化或者扩展一元和二元函数对象适配器是

一种特殊的类它被分成下面两类：

1 绑定器binder ( binder ) 通过把二元函数对象的一个实参绑定到一个特殊的值上

将其转换成一元函数对象例如为了计数一个容器中小于或等于10 的元素的个数我们可能会向count_if()传递一个less_equal 函数对象以及一个被绑定为10 的实参。

2 取反器negator ( negator ) 是一个将函数对象的值翻转的函数适配器例如为了

计数一个容器中所有大于10 的元素的个数我们可以向count_if()传递less_equal 函数对象的

negator 该函数对象有一个实参被绑定为10 当然在这种情况下直接传递greater 对象

的binder 并把一个实参绑定为10 更为简洁明了。

C++标准库提供了两种预定义的binder 适配器bind1st 和bind2nd 正如你所预料的

bind1st 把值绑定到二元函数对象的第一个实参上bind2nd 把值绑定在第二个实参上例如

为了计数容器中所有小于或等于10 的元素的个数我们可以这样向count_if()传递

count_if( vec.begin(), vec.end(),

bind2nd( less_equal<int>(), 10 ));

标准库提供了两个预定义的negator 适配器not1 和not2 同样正如你所料想的not1

翻转一元预定义函数对象的真值而not2 翻转二元谓词函数的真值为了取反less_equal 函

数对象的绑定我们可以这样写

count_if( vec.begin(), vec.end(),

not1( bind2nd( less_equal<int>(), 10 )));

实现函数对象

函数对象类定义的最简单形式包含一个被重载的函数调用操作符例如下面是一个二

元函数对象它判定一个值是否小于等于10

// 函数对象类的简单形式

class less_equal_ten {

public:

bool operator() ( int val )

{ return val <= 10; }

};

使用这个对象的方式与使用预定义函数对象的方式相同例如下面是修改后的count_if()

调用它使用了我们的函数对象

count_if( vec.begin(), vec.end(), less_equal_ten() );

毫无疑问这个类是相当局限的我们可以应用一个negator 来计数容器中大于10 的元

素的个数

count_if( vec.begin(), vec.end(),

not1(less_equal_ten()) );

我们也可以通过允许用户提供一个与每个元素比较的值来扩展我们的实现一种做法是

引入一个数据成员来存储被比较的值以及一个构造函数把这个成员初始化为用户指定的值

class less_equal_value {

public:

less_equal_value( int val ) : _val( val ) {}

bool operator() ( int val ) { return val <= _val; }

private:

int _val;

};

我们现在用这个对象指定一个任意的整数值例如下面的调用计数小于等于25 的元素

的个数

count_if( vec.begin(), vec.end(), less_equal_value( 25 ));

另外一种类的实现方式不使用构造函数它根据被比较的值对类参数化例如

template < int _val >

class less_equal_value {

public:

bool operator() ( int val ) { return val <= _val; }

};

下面给出了怎样调用这个类来计数小于等于25 的元素的个数

count_if( vec.begin(), vec.end(), less_equal_value<25>() );

#include <string>

#include <vector>

#include <ctype.h>

using namespace std;

const char *const program_name = "comline";

const char *const program_version = "version 0.01 (08/07/97)";

inline void usage( int exit_value = 0 )

{

        // 输出一个格式化的用法信息

        // 并用 exit_value 退出...

        cerr << "usage:\n"

        << program_name << " "

        << "[-d] [-h] [-v] \n\t"

        << "[-o output_file] [-l limit] \n\t"

        << "file_name\n\t[file_name [file_name [ ... ]]]\n\n"

        << "where [] indicates optional option: \n\n\t"

        << "-h: help.\n\t\t"

        << "generates this message and exits\n\n\t"

        << "-v: version.\n\t\t"

        << "prints version information and exits\n\n\t"

        << "-d: debug.\n\t\tturns debugging on\n\n\t"

        << "-l limit\n\t\t"

        << "limit must be a non-negative integer\n\n\t"

        << "-o ofile\n\t\t"

        << "file within which to write out results\n\t\t"

        << "by default, results written to standard output \n\n"

        << "file_name\n\t\t"

        << "the name of the actual file to process\n\t\t"

        << "at least one file_name is required --\n\t\t"

        << "any number may be specified\n\n"

        << "examples:\n\t\t"

        << "$command chapter7.doc\n\t\t"

        << "$command -d -l 1024 -o test_7_8 "

        << "chapter7.doc chapter8.doc\n\n";

        exit( exit_value );

}

int main( int argc, char* argv[] )

{

        bool debug_on = false;

        bool ofile_on = false;

        bool limit_on = false;

        int limit = -1;

        string ofile;

        vector< string > file_names;

        cout << "illustration of handling command line arguments:\n"

        << "argc: " << argc << endl;

        for ( int ix = 1; ix < argc; ++ix )

        {

                cout << "argv[ " << ix << " ]: "

                << argv[ ix ] << endl;

                char *pchar = argv[ ix ];

                switch ( pchar[ 0 ] )

                {

                        case '-':

                        {

                                cout << "case \'-\' found\n";

                                switch( pchar[ 1 ] )

                                {

                                case 'd':

                                        cout << "-d found: "

                                        << "debugging turned on\n";

                                        debug_on = true;

                                        break;

                                case 'v':

                                        cout << "-v found: "

                                        << "version info displayed\n";

                                        cout << program_name

                                        << " :: "

                                        << program_version

                                        << endl;

                                        return 0;

                                case 'h':

                                        cout << "-h found: "

                                        << "help information\n";

                                        // 这里没必要用 break 了, usage() 可以退出

                                        usage();

                                case 'o':

                                        cout << "-o found: output file\n";

                                        ofile_on = true;

                                        break;

                                case 'l':

                                        cout << "-l found: "

                                        << "resource limit\n";

                                        limit_on = true;

                                        break;

                                default:

                                        cerr << program_name

                                        << " : error : "

                                        << "unrecognized option: - "

                                        << pchar << "\n\n";

                                        // 这里没必要用 break 了, usage() 可以退出

                                        usage( -1 );

                                }

                                break;

                        }

                        default: // 或文件名

                        cout << "default nonhyphen argument: "

                        << pchar << endl;

                        if ( ofile_on ) {

                                ofile_on = false;

                                ofile = pchar;