c++语法 string+

C++文件

例：从文件income. in中读入收入直到文件结束，
并将收入和税金输出到文件tax. out。

#include using namespace std; const int cutoff = 6000; const float rate1 = 0.3; const float rate2 = 0.6; int main() { ifstream infile; ofstream outfile; int income,tax; infile.open("income.in") outfile.open("tax.out") while( infile>>income){ if( incomereturn age;} private: unsigned age; };

通过在进行成员函数声明的时候使用inline关键字，可将原本定义在类声明之外的成员函数强制变成内联函数。

class Person{ public: inline void setAge(unsigned n); inline unsigned getAge() const; private: unsigned age; }; //define Person's setAge void Person::setAge(unsigned n){ age = n; } //define Person's getAge unsigned Person::getAge() const{ return age; }

在程序中使用类
关键步骤：类声明，对象定义，客户服务请求

#include using namespace std; class Person{ public: void setAge(unsigned n){age = n;} unsigned getAge() const{ return age;} private: unsigned age; }; int main() { Person p; //create a single person Person stooges[3]; //create an array of Persons p.setAge(12); //set the stooges' age stooges[0].setAge(45); stooges[1].setAge(46); stooges[2].setAge(44); //print four ages coutreturn num;} private: int num; };

const 成员函数
定义一个const成员函数时，const关键字出现在参数列表与其函数体之间。
由于get成员函数不更改任何数据成员，因此这种类型的函数被称为只读函数。将成员函数标记为const可以预防对该函数所属对象的数据成员的误写，同时有些编译器还可对这种情况进行一些优化。
一个const成员函数仅能调用其它const成员函数，因为const成员函数不允许直接或间接地改变对象的状态，而调用非const成员函数可能会间接改变对象的状态

class C{ public: void m1(int x) const{ m2(x); //*** error: m2 not const } void m2(int x) { dm = x;} private: int dm; };

const成员函数
const关键字三种不同用法示例：
- 在成员函数set中，因为set不该变string类型参数n，n被标为const。
- 成员函数get返回数据成员name的一个const型引用，此处的const表明谁也不能通过这个引用来修改数据成员name的值。
- 成员函数get本身被标记为const，因为get不会改变类C唯一的数据成员name的值。

class C{ public: void set( const string& n) {name = n;} const string& get() const{ return name;} private: string name; };

const返回
- 某函数如果采用const返回，则其返回值只能赋给一个const类型的局部变量。
- 如果该const返回值是一个类的指针或者引用的话，则不能用该指针或引用调用该类的non-const成员函数，因为这些函数可能会改变该类的数据成员的值。

class Foo{ public: /* * Modifies m_widget and the user may modify the reurned widget. */ Widget *widget(); /* * Does not modify m_widget but the user may modify the returned widget. */ Widget *widget() const; /* * Modifies m_widget, but the user may not modify the returned widget. */ const Widget *cWidget(); /* * Does not modify m_widget and the user may not modify the returned widget. */ const Widget *cWidget() const; private: Widget *m_widget; }; int main() { Foo f; Widget *w1 = f.widget(); //fine Widget *w2 = f.cWidget(); //error -"cWidget()" // returns a const value // and "w2" is not const const Widget *w3 = f.cWidget(); //fine return 0; }

对成员函数进行重载以便处理两种类型的字符串

class C{ public: void set( const string & n) {name = n;} void set( const char* n) { name = n;} const string& get() const { return name;} private: string name; }; C c1; string s1("Who's Afraid of Virginia Woolf?"); c1.set(s1); // string argument C c2; c2.set( "What, me worry?"); //const char*

构造函数和析构函数

有些函数比较特殊，在调用它们时不需要显式地提供函数名，编译器会自动地调用它们。
类构造函数（class constructor, 可以有多个）和类析构函数(class destructor，最多一个）就是这种类型的函数，通常编译器会自动调用这两个函数而不需要我们显式地发出调用动作。

构造函数：是一种与类名相同的成员函数。当创建类的一个实例时（例如，定义一个类的变量时）,编译器会自动地调用某个合适的构造函数。下面的例子中，三个成员函数是构造函数，都有着与类相同名称的Person，而且没有返回值类型。

class Person{ public: Person();// constructor Person( const string & n); // constructor Person( const char* n); //constructor void setName( const string& n); void setName( const char* n); const string& getName() const; private: string name; };

构造函数不能有返回类型，因此void Person();是错误的。
一个类可以拥有多个构造函数，可以对构造函数进行重载。但每个构造函数必须拥有不同的函数签名。
上个例子中，三个构造函数具有不同的函数签名。
第一个没有参数（默认构造函数），第二个参数类型是const string引用（带参数沟槽函数），第三个的参数类型是C风格字符串const char*（带参数构造函数）。

构造函数的使用：

#include "Person.h" //class declaration int main() { Person anonymous; //default constructor Person jc("J.Coltrane"); // parameterized constructor //... }

当创建一个对象时，构造函数会被编译器自动调用。程序员不需要调用构造函数。构造函数主要用来对数据成员进行初始化，并负责其他一些在对象创建时需要处理的事务。构造函数对提高类的健壮性有重要的作用。

之前的stack类没有构造函数，为保证一个stack正确运行，top成员必须初始化为-1.虽然stack提供了init成员函数来完成这个初始化任务，但程序员可能会在创建一个stack对象之后忘了调用init成员函数而出错。可以通过为stack类增加一个默认构造函数，这样当定义一个stack对象时，编译器自动调用其默认构造函数，默认构造函数再调用init成员函数：

class Stack{ Stack() {init();} //ensures initialization //... };

构造函数最大的特点是：函数名与类名相同，没有返回类型。
除此之外，构造函数的行为与其他函数相同，也可完成如赋值、条件测试、循环、函数调用等功能。
构造函数既可以在类声明之中定义，也可在类声明之外定义。
下例子中，将默认构造函数定义为inline类型，将带参数构造函数定义放到类声明之外。

class Person{ public: Person() {name = "Unknown";} Person( const string& n); Person( const char* n); void setName( const string& n); void setName( const char* n); const string& getName() const; private: string name; }; Person::Person( const string& n){ name = n; } Person::Person( const char* n){ name = n; }

对象数组与默认构造函数：
如果C是一个类，可以定义任意维数的C对象数组；
如果C拥有默认构造函数，数组中每个C对象都会调用默认构造函数。

#include using namespace std; unsigned count = 0; class C{ public: C() { coutreturn n;} //... private: static unsigned n; //count of Task objects //... };

静态成员函数只能访问其他的static成员，包括数据成员和成员函数。而非静态成员函数既可以访问static成员，也可以访问非静态成员。
static成员函数既可以是inline函数，也可以是非inline函数

class Task { public: static unsigned get() { setST(); //*****ERROR: NOT static! st = time ( 0 ); //***** ERROR: not static! return n; // ok,n is static } //... };

访问static数据成员和static成员函数的方式：
通过对象来访问；直接通过类来访问（推荐）

class C{ public : static int sVar; static void sMeth(); //... }; int main(){ C c1; c1.sMeth(); //through an object C::sMeth(); //directly and preferred unsigned x = c1.sVar; //through an object unsigned y = C::sVar; //directly and preferred //... }

在成员函数内定义静态变量
成员函数内的局部变量可以是static的。如果将成员函数内的某个局部变量定义为静态变量，该类的所有对象在调用这个成员函数时将共享这个变量。

class C{ public: void m() ; //object method private: int x; //object data member }; void C::m() { static int s = 0; //*****Caution: 1 copy for all objects cout month = mn; (*this).month = mn; }

上述三条语句是等价的。
this指针通常用来从成员函数中返回当前对象。
return *this；
this指针有时也用来避免自引用
if (&Object != this)
this指针是一个常量，它不能作为赋值、递增、递减等运算的目标对象。此外this只在非static成员函数中用才有效。
与普通函数相比，静态成员函数由于不与任何对象相联系，因此它不具有this指针。由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长。

继承

C++允许从任何已存在的类派生新类，所派生的类被称为派生类(derived class)，又称为子类。而已存在的用于派生新类的类被称为基类(base class)，又称为父类。
在C++中，一个派生类既可以从一个基类派生，也可以从多个基类派生。
从一个基类派生类的继承被称为单继承。
从多个基类派生类的继承被称为多继承。

C++中继承的语法：
单继承语法：

class 派生类名 : 访问控制 基类名 { 数据成员和成员函数声明 };

多继承语法：

class 派生类名 : 访问控制 基类名1，访问控制 基类名2，... 访问控制 基类名n { 数据成员和成员函数声明 };

类继承举例：
单继承：
class Bear : public ZooAnimal
{ … };
多继承：
class Panda : public Bear, public Endagered
{ … };
其中：
public: 访问控制关键字，指明继承方式是公有继承。
当一个类通过公有继承方式从基类继承时，基类中的公有成员在派生类中也是公有的。
不指明继承方式关键字public时，编译器会默认继承方式为private或protected。
“:”用于建立基类与派生类的层次结构。
基类：C++提供的或用户自定义的类。
派生类中可以定义数据成员和成员函数，此外，还继承基类所有成员。

class Pen{ public: enum int {Off, On}; void set_status( ink ); void set_location(int ,int); private: int x; int y; ink status; }; class CPen : public Pen { public: void set_color( int ); private: int_color; };

继承机制下的私有成员
基类的所有私有成员仅在基类中可见，而在派生类中是不可见的。
但派生类对象会为基类中的所有私有成员分配空间。
如上个例子中，CPen类从Pen类继承了数据成员x，y和status，尽管这些成员在CPen类中是不可见的，但无论何时创建CPen类的对象时，该对象都将获得相应的存储空间来保存x，y和status等数据成员。
尽管在派生类中不能直接访问基类的私有成员，但可以通过间接的方式（调用从基类继承来的公有成员函数）进行。
如上个例子中，x，y和status可以通过成员函数set_location和set_status进行访问。

class Point { public: void set_x( int x1 ) { x = x1; } void set_y( int y1 ) { y = y1; } int get_x() const {return x;} int get_y() const {return y;} private: int x; int y; }; class Intense_point : public Point { public: void set_intensity( int i ) { intensity = i; } int get_intensity() const { return intensity;} private: int intensity; };

改变访问限制：
使用using声明可以改变成员在派生类中的访问限制。例如：基类中的公有成员一般情况下被继承为公有成员，但使用using声明可将其改为私有成员（或保护成员）

class BC { //base class public: void set_x( float a ) { x = a;} private: float x; }; class DC : public BC { //derived class public: void set_y(float b) { y = b; } private: flaot y; usign BC::set_x; };

这样就无法直接通过DC类的任何对象调用set_x：

int main() { DC d; d.set_y(4.31); //OK d.set_x(-8.03); // ***** ERROR:set_x is private in DC //... }

如果基类的某个公有成员函数在继承类中不适合，则可以通过using声明将其转变为私有成员函数，从而使它在派生类中隐藏起来。
例如，“有序元素类”从“无序元素类”派生而来，基类“无序元素类”中的某些成员函数可能并不适合“有序元素类”。
如基类中某个成员函数的算法为：在一个无序表中的任意位置插入一个元素。这个算法显然不符合有序表的处理要求。这样的成员函数就应通过using声明将其在派生类中隐藏起来。

名字隐藏
如果派生类添加了一个数据成员，而该成员与基类中的某个数据成员同名，新的数据成员就隐藏了继承来的同名成员。