// 发送给cin的输入被缓冲。这意味着只有用户按下回车之后，他输入的内容才会发送给程序

所以 # 后面可以跟其他的字符。

// cin 将忽略空格和换行符，统计时候不算空格

   char ch;

    int cnt = 0;

    cin >> ch;

    while(ch != '#')

    {

        cout << ch;

        ++cnt;

        cin >> ch;
        // cin.get(ch); 此时就可以读取空格了

    }

    cout << endl << cnt << "characters read\n";

while ( cin.fail() == false )

{

}

int a;

while(cin >> a)  //当输入整形时正常运行，当输入错误例如输入字符或者OEF都导致cin返回false

{

    cout << a << endl;

}

for(int i = ; i < Max; i++）

{

    cout << "round #" << i +  << ": ";

    while (! (cin >> golf[i] ) )

    {

        cin.clear();   // 重新设置输入状态

        while(cin.get() != '\n')  // 将读取的错误内容清除掉

            continue;

        cout << "Please enter a number: ";

     }

}

如果输入失败(即!(cin>>golf[i])表达式的值为true)，则进入while循环，然后使用clear重置输入，紧接着cin.get()从错误输入的第一个字符开始依次读取错误字符，直到遇到换行符（注意，这里的换行符是前面cin在从键盘读取读取输入时，在行尾自动添加的），特别注意：这里的内层while循环只包含一条语句，即continue语句，如果测试条件为真，则continue使程序返回到while(cin.get() != 'n')语句，从而达到依次读取字符的目的。当cin.get()读取到换行符时，测试条件为false，内层while不在执行循环体，至此程序使用cin.get()达到了删除整行的作用，此时程序执行下一条语句：cout<<" Please enter a number: ";提示用户重新输入一个数字!

  char automobile[];

    int year;

    double a_price;

    double b_price;

    ofstream outFile;

    outFile.open("carinfo.txt");

    cout << "Enter the make and model of automible: ";

    cin.getline(automobile, );

    cout << "Enter the model year: ";

    cin >> year;

    cout << "Enter the original asking price: ";

    cin >> a_price;

    b_price = a_price * 0.913;

    outFile << fixed;

    outFile.precision();

    outFile.setf(ios_base::showpoint);

    outFile << "Make and model: " << automobile << endl;

    outFile << "Year: " << year << endl;

    outFile << "was asking $: " << a_price << endl;

    outFile << "Now asking $: " << b_price << endl;

    outFile.close();

 char filename[SIZE];

    ifstream inFile;  // 声明ifstream变量

    cout << "Enter name of data file: ";

    cin.getline(filename, SIZE);

    inFile.open(filename);  // 调用open() 打开文件

    if(inFile.is_open() == )  // 判断是否被成功打开

    {

        cout << "Could not open the file " << filename << endl;

        cout << "Program terminating.\n";

        exit(EXIT_FAILURE);  // cstdlib库函数中定义了一个同操作系统通信的参数值EXIT_FAILURE。函数exit()终止程序

    }

    double value;

    double sum = 0.0;

    int cnt = ;

    inFile >> value;

    while(inFile.good())  // 判断读取是否正确，EOF 或者格式是否匹配

    {

        ++cnt;

        sum += value;

        inFile >> value;

    }

    //如果结束就分情况判断是哪种情况引起的结束

    if(inFile.eof())   // 遇见EOF

        cout << "End of file reached." << endl;

    else if(inFile.fail())  //类型不匹配

        cout << "Input terminated by data mismatch." << endl;

    else

        cout << "Input terminated for unknown reason." << endl;

    if(cnt == )

        cout << "No data processed." << endl;

    else

    {

        cout << "Items read: " << cnt << endl;

        cout << "Sum: " << sum << endl;

        cout << "Average: " << sum / cnt << endl;

    }

    inFile.close(); 

struct node

{

    string name;

    double money;

    int flag;

};

int main()

{

    int num;

    cin >> num;

    cin.get(); //接受回车

    node *p = new node[num];  // node类型的指针p

    for(int i = ; i < num; i++)

    {

        getline(cin, (p + i) -> name);  // 通过指针 + 偏移

        cin >> (p + i) -> money;

        cin.get();

     }

 int sum_arr(const int * Begin, const int * End)  // 求一个数组任意区间和， const 表示不可更改

 {

     int * pt,sum = ;

     for (pt = Begin; pt != End; pt++)

         sum += *pt;

     return sum;

 }

const int a = 10; //a是一个常量，不允许修改，但是可以通过一级指针进行修改
int *pt = &a;
*pt = 100;  //此时便可以修改const
int age = ;

const int * pt = &age;  // pt 指向一个const int 因此不能用pt来修改这个值，换句话来说，*pt的值为const 不能通过 *pt = ？来修改

// 但可以修改 pt 值，即将一个新地址赋给pt

int sage = ;

pt = &sage; 此时 *pt就是80了

int * const pt = &age; //表示不能修改指针的位置，但是可以修改值，也就是说 pt = &sage,是不行的，但是可以*pt = ?来修改值

const int* const pt = &age //表示此时pt只能指向age的位置，且不能修改age处的值

---------------------------------------

int sloth = ;

const int * ps = &solth;

int * const finger = &solth; // 这种声明使得finger只能指向sloth，但允许用finger 来修改 solth 值

总结： finger 和 *ps 是 const，而*finger 和 ps 不是const
指针存放的是地址，在32位的系统中 任何类型（int*,char *, float等等）的指针都是 4 字节

空指针：NULL
野指针：指向未知位置的指针

const float g_earth = 9.80;

const float * pe = &g_earth //valid

const float g_moon = 32.0;

float * pm = &g_moon; // invaild 只能将非const数据类型的地址赋给非const

const int month[] = { };

int sum(int arr[], int n)

int j = sum(month, ); // invaild、

const double * const stick = & trouble // 此时的stick只能指向trouble，而stick不能用来修改trouble的值，简而言之 stick 和 *stick 都是const

------------------------------

void show_array(const double arr[], int n)

//第一个参数其实也可以写成 const double * arr，也就是说不能修改arr指向的值，即不能修改数组的值

int sum ( int (*arr) [], int size) // 四个指向int的指针组成的数组

int sum (int arr[][], int size) // 含义同上

int *arr2[]  //一个指向由4个 int组成的数组指针

ar2[r][c] = *(*(ar2 + r ) + c)  // same thing

ar2  // 指向第一行的的（四个指针数组）

ar2 + r // 指向第 r 行的（四个指针数组）

*(ar2 + r) //指向这一行第一个数的指针，类似 ar[r]

*(ar2 + r) + c // 指向 这一行这一列的指针

* (*（ar2 + r) + c) // so...

while（*str) {  // 遍历一个字符串，当结束'\0‘（空字符）出现时结束，

    str++;

}

#include <array>

array<double, > expenses; // 定义了一个数组，5个double类型

void fill( array<double, > * pa) // 指针传递array数组

{

    for( int i = ; i < ; i++)

        cint >> (*pa)[i];     //pa是指向array对象的指针，因此*pt是为这种对象，而（*pt)[i] 是该对象的一个元素

}

int think();

process(think); // 参数是函数地址，直接传递函数名

thought(think()); //参数是函数的返回值

.声明函数指针：

double pam(int);

double (*pf) (int);  //与pam()声明类似，这是将pam替换成了（*pf)。pam是函数，因此（*pf)也是函数，如果 pf 就是函数指针

double *pf （int)意味着 pf() 是一个返回指针的函数

double (*pf)(int)意味着pf是一个指向函数的指针

------------------------------------------------------------------------------------

将函数的地址付给它

double pam（int);

double (*pf) (int);

pf = pam; // pf指向pam函数

------------------------------------------------------------------------------------

使用指针来调用函数

double betsy(int lns)

{

    return 0.5 * lns;

}

void estimate(int lines, double (*pf) (int) )

{

    cout << lines << " lines will take ";

    cout << (*pf) (lines) << " hour(s)" << endl;  // 直接使用（*pf）（参数）来调用函数，c++也允许 pf(lines)这样来调用，两种调用都可以

}

int main() {

    cin >> code;

    estimate(code, besty);

}

内联函数主要是用来代替宏的，因为宏有缺陷，主要就是宏展开后是一个文本，尤其是在四则运算过程中会丢掉想要表达的一下
inline double squrae(double x) {return x * x;} //内联函数，编译器使用相应的函数代码替换函数调用。程序无需调到另一个位置处执行代码在跳回来。快但占用内存，空间换时间思想

------------------------------------------------

#define SQUARE(X) X*X //而是通过文本实现

SQUARE(3.5 + 5.4) 展开后为 3.5 + 5.4 * 3.5 + 5.4

int rats = ;

int &rodents = rats; // rodents是rats的引用，他们的值和地址都是相同的，并且一个变化另一个也变化

---------------------------------------------------------------------------

临时变量 和 const

如果引用参数是const，编译器在下面两种情况下会生成临时变量

. 实参类型正确，但不是左值（左值是指变量，数组等）， 不是左值形如 x + ;

.实参类型不正确，但可以转换成正确的类型

// const状态就不可以

double recube (const double & ra) {

    return ra * ra * ra;

}

int main() {

    double rd = 3.2;

    double c1 = recube(rd + ); // 可以的，这就 不是左值的情况

    int rrd = ;

    double c2 = recube(rrd) //也是可行的

}

// 在上面情况编译器都将生成一个临时匿名变量，并将ra指向它。临时变量只在函数调用期间存在，此后编译器可以随时删除。

 void display(const free_throws & ft); //不希望函数修改传入的结构，就这个函数而言也可以按值传递结构，但与复制原始结构的拷贝相比，使用引用可节省时间和内存

 free_throws & accumulat(free_throws & target, const free_throws & source) {

     target.attempts += source.attempts;

     target.made += source.made;

     return target;

 } // 返回是一个引用

 dup = accumulat(team, five) // 将team的值赋给dup

 独特的一个用法：

 accumulat(dup, five) = four // 由于函数返回的是指向dup的引用，所以上述代码与下面的代码等效

 accumulat（dup, five);

 dup = four;

 .为何要返回引用

 //传值是将这个值复制到一个临时位置，在由调用程序使用

 //返回引用：就是直接复制，不用临时变量，效率高

 .返回引用注意的问题

    .避免返回的是一个指向临时变量的引用，因为调用完函数后他就不存在了

    .一般简单方法返回一个作为参数传递给函数的引用

    . const free_throws & clone (free_throws & ft) {

           free_throws * pt;

           *pt = ft;

             return *pt

         } //第一条语句创建一个无名的free_throws结构，并让指针pt指向该结构，因此*pt就是该结构。函数声明表明，该函数将返回这个结构的引用。

 就可以这样使用该函数 ：free_throws & jolly = clone(there)

 这使得jolly成为新结构的引用。这个方法存在一个问题：在不需要new分配的内存是，应使用delete来释放他们。调用clone()隐藏了对new的调用，这使得以后很容易忘记delete来释放内存

 、为何将const用于引用返回类型

 accumulate(dup, five) = four;

 在赋值语句中，左边必须是可修改的左值。左边的字表达式必须标识一个可修改的内存块。在这里，返回指向dup的引用，确实标识是一个这样的内存块。

 常规（非引用）返回类型是右值--不能通过地址访问的值

函数重载原理：可能是编译器将重载函数自己定义另外一个名字，
如果没有匹配原型并不会自动停止使用其中的某个函数，因为C++将尝试使用标准类型转换强制进行匹配。如果多个函数原型都可转换，将拒绝这种函数调用

double cube (double x);

double cube(double & x);

//类型引用和类型本身视为同一个特征标

//匹配函数时，并不区分const 和 非const变量

//返回类型可以不同，但特征标也必须不同

long gronk（int n, float m);

double gronk （float n, float m);

const与重载：

int M(int a);
int M(const int a);
从调用者的角度看，所有的形参都是无法修改实参值的，语义相同，这样构不成重载。
int M(int &a);
int M(const int &a);
const引用无法修改引用对象值，但是普通引用却可以，语义不同，可以构成重载

template <typename T> // typename可以用class替代

void Swap(T &a, T &b);

int main() {

   swap( a, b); 可以定义各种类型的a,b；

    return ;

}

template <typename T>

void Swap(T &a, T &b)

{

    T temp;

    temp = a;

    a = b;

    b = temp;

}

//函数模板不能缩短可执行程序。最终编译的时候，生成各自的版本

//好处就是生成多个函数定义简单、可靠

template <typename T>

void Swap(T a, T b);

template <typaname T>

void Swap(T * a, T * b, int n); //重载，参数个数不同

-------------------------------------------------------------------

//实例化和具体化

编译器使用模板为特定类型生成函数定义时，得到的是模板实例。例如，函数调用Swap(i,j)导致编译器生成Swap()的一个实例，该实例使用int类型。模板并非函数定义，但使用int的模板实例是函数定义。这种实例化方式被称为隐式实例化。显式实例化直接名利编译器创建特定的实例，如Swap<int>() 标准格式：template void Swap<int>(int, int);

显式具体化使用下面两个等价的声明之一：

template <> void Swap<int> (int &, int &);

template <> void Swap(int &, int &);

区别在于，这些声明的意思是"不要使用Swap（）模板来生成函数定义，而应使用专门的int类型显式的定义函数定义“。这些原型必须有自己的函数定义。显式具体化声明在关键字template后包含<>,而显式实例化却没有

// cexternal.cpp

double warming = 0.3;

int main() {

     return ;

}

// support.cpp

extern double warming; // 另一个文件可以直接用上一个文件的变量warming

void local() {

    double warming = 0.8;

    cout << warming << endl;  //显示0.8,

    cout << :: warming << endl; //显示全局变量0.3

}

struct date {

    char name[];

    mutable int access;

};

const date veep = { "fafaf", };

veep.access++  // allowed

extern const int states = ;

static int private(double x);

....

static int private(double x) {  //该函数只能在这个文件中可见，还可意味着可以再其他文件定义同名的函数

    ...

}

//另一种形式的链接性--语言链接性

C语言中一个名称只对应一个函数，为了满足内部需求，C语言编译器可以将spiff这样的函数名翻译成_spiff。这被称为C语言的链接性。但在C++中，同一个名称可以对已多个函数，必须将这些函数翻译成不同的符号名称。C++编译器执行名称矫正或者名称修饰，为重载函数生成不同的符号名称。spiff(int)转换成_spiff_i等。。

C++程序中使用C库中的预编译的函数，可以用函数原型来指出要使用的约定：

extern "C" void spiff(int);  //解决c++中调用c语言

extern void spiff(int) // c++

extern "C++" void spiff(int)

//使用new运算符的初始化

int * pi = new int();

//C++ 11可以初始化常规结构或数组

struct where { double x, double y, double z};

where * one = new where {2.5, 5.8, 7.2};

int * ar = new int [] {, , , };

--------------------------------

定位new运算符：new要在堆里找到一个足够满足要求的内存块，还有一种变体，被称为定位new运算符，他让您能指定要使用的位置

#include <new> // 必须使用new头文件

struct chaff {

    char dross[];

    int slag;

};

int buffer1[;

int buffer2[];

int main() {

    charff * p1;

    char * p2;

    p1 = new (buffer1) chaff; // 从buffer1中分配空间给结构chaff

    p2 = new (buffer2) int[]; // 从Buffer2中分配空间给一个包含20个元素的int数组

}

------------------------------------

定位new运算符不跟踪哪些内存单元已经被使用，它默认从头开始，如果有就覆盖。除非给了指定偏移

pd2 = new (buffer + N * sizeof(double) ) double [N];

void * 是指空类型的指针

void * a;

int * b;

float * c;

b = c // 错误

a = b //可以，其他所有都能赋值给空类型

b = a // 错误, 空类型赋值给其他需要进行强制类型转换 b = (int* ) a
//void* 需要注意的是，他一旦接受其他类型，就不能再转换成另一个类型
如下

#include <stdio.h>

int main (){

int a= 10;

void *b = &a;
printf("int a = %d\n",a);
printf("void (int *)b =%d \n",*(int *)b);
printf("void (double *)b =%d \n",*(double*)b); //编译器并不会报错但是其结果却有点出人意料
return 0;
}

void有两个用处
1、表示函数返回不需要返回值
2、对函数参数类型限制：表示该函数不接受参数，如 int fun（void）

namespace Jack {  //一个Jack的命名空间

    double pail;

    void fetch();

    int pal;

    struct Well {...};

}

//using 声明 和 using 编译指令

//using 声明： 使一个名称可用

using Jack:: pail; //就相当于声明一个变量

double pail;   //所以这句是不允许的，已经声明了一个

//using 编译指令：使所有的名称都可用

using namespace Jack; // 然后就可以随便的使用名称空间的变量了

int pail; // 也是允许的只不过把原来的覆盖掉

-------------------------------------------

同一名称空间的相同名称的变量表示不同的内存单元

jack::pal 和 jill:: pal

-------------------------------------------------

using namespace Jill // 只是该名称空间可以在这个文件或者函数内可用

超过了就不能用了。

编译指令 如果有相同的就会发生覆盖，必要时可以用作用于解析运算符进行使用  Jill::fet 表示使用Jill里面的， ::fet表示使用全局的

-------------------------------------------------------

using声明比using编译指令安全

名称空间其他特性：

//可以嵌套

namespace elements {

    namespace fire {

        int flame;

        ...

     }

     float water;

}

//这里flame是指 element::fire::flame。同样可以使用下面using编译指令使内部的名称可用using namespace elements::fire;

//可以给命名空间创建别名

namespace mvft = myth::elements::fire

using mvft::flame

未命名的名称空间

namespace {

    int ice;

    int bandycoot;

}

//未命名的空间跟全局变量相似，由于没有名称，不能显示的使用using编译指令和using声明。不能再未命名空间所属文件之外的其他文件中使用该名称空间的名称。其实就是static的替代品

使用构造函数：

Stock food = Stock("World Cabbage", , 2.5); //显式的调用

Stock garment("Furry Mason", , 2.5); //隐式的调用

还可以用new来分配

Stock * pstock = new Stock("Electroshock Games", , 19.0);

-----------------------------------

默认构造函数

Stock fluffy_the_cat;

C++自动提供默认构造函数。默认构造函数如下

Stock::Stock() {}  //无参数，不含值

如果已经声明了定义了其他带有参数的构造函数就不能使用默认构造函数

定义默认构造函数两种方式：

、给已有构造函数所有参数提供默认值

    Stock（const string & co = "Error", int n = , double pr = 0.0);

    Stock stock; //直接调用

、Stock （） {}

     Stock stock; //一样调用

     或者 Stock stock = Stock();

//只能存在一个默认构造函数

什么时候调用析构函数由编译器决定，通常不应再代码中显式的调用析构函数。如果创建的是静态存储类对象，其析构函数在程序结束时自动调用，如果创建的是自动存储类对象，其析构函数在程序执行完代码块时自动调用，如果对象时通过new创建的，程序驻留在栈内存，当使用delete来释放内存是，其析构函数将自动被调用。最后程序可以创建临时对象来完成特殊操作，在这种情况下，程序在结束该对象的使用时自动调用其析构函数。

如果没有析构函数，编译器隐式的声明一个默认析构函数。

using std::cout;

    cout << "Using constructor to create new objects\n";

    Stock stock1("NanoSmart", , 20.0);

    Stock stock2 = Stock("Boffo Objects", , 2.9);

    // 对stock1和stock2初始化

    cout << "Assigning stock1 to stock2:\n";

    stock2 = stock1;//可以赋值

    cout << "Listing stock1 and stock2:\n";

    stock1.show();

    stock2.show();

    cout << "Using a constructor to reset and object.\n";

    stock1 = Stock("Nifty Foods", , );  // stock1已存在，这不是初始化，所以这是通过让构造函数创建一个新的、临时的对象，然后将其内容复制给stock1来实现的，随后程序调用析构函数，以删除该临时对象

    cout << "Revised stock1:\n";

    stock1.show();

//main函数结束时，其局部变量将消失，由于自动变量是放在栈中，所以后创建的先被删除

const 成员函数：

void show() const;保证不改变调用对象的值

函数定义：

void Stock :: show() const;

如果方法需要引用整个调用的对象，则可以使用表达式*this，在函数的括号后面使用const限定符将this限定为const，这样将不能使用this来修改对象的值

this是地址
void Stock :: show() cosnt {
}
top.show();
转换为下面这样的C-风格定义
void show(const Stock * this) {
 }
show(&top);

Stock stock[STKS] = {

        Stock("NanoSmart", , 20.0),

        Stock(),

        Stock("Monolithic Obellisks", , 3.23),

        Stock("Fleep Enterprise", , 3.3),

    };

在类中定义的名称的作用域都是整个类；在不同类中使用相同的类成员名而不会发生冲突

声明类只是描述了对象的形式，并没有创建对象，在创建对象之前没有用于存储值得空间
class Bakery {
private:
    const int Month = 12;
    double costs[Month];  //是不合法的，因为在创建对象之前Month是没有值的
//在类中定义常量的方式--使用关键字 static
class Bakery {
private:
    static const int Month = 12;
    double cost[Month];
}//创建一个名为Month的常量，该常量与其他静态变量存储在一起，不是存储在对象中，因此只有一个Month常量，被所以Bakery对象共享。

 //Time Sum(const Time & t) const;

    Time operator+(const Time & t) const;

    Time operator-(const Time & t) const;

    Time operator*(double n) const;

Time Time::operator+(const Time & t) const

{

    Time sum;

    sum.minutes = minutes + t.minutes;

    sum.hours = hours + t.hours + sum.minutes / ;

    sum.minutes %= ;

    return sum;

}

Time Time::operator-(const Time & t) const

{

    Time diff;

    int tot1, tot2;

    tot1 = t.minutes +  * t.hours;

    tot2 = minutes +  * hours;

    diff.minutes = (tot2 - tot1) % ;

    diff.hours = (tot2 - tot1) / ;

    return diff;

}

Time Time::operator*(double mult) const

{

    Time result;

    long totalminutes  = hours * mult *  + minutes * mult;

    result.hours = totalminutes / ;

    result.minutes = totalminutes % ;

    return result;

}

void Time::Show() const

{

    std::cout << hours << " hours, " << minutes << " minutes\n";

}

重载调用：两种方法都是可以的

    total = coding.operator+(fixing);

    total = coding + fixing;

同时也是支持两个以上对象累加

t4 = t1 + t2 + t3;

t4 = t1.operator(t2 + t3) //加法是从左到右结合的，所以显示t1调用

t4 = t1.operator(t2.operator(t3));

//重载限制

、不能违反运算符原来的句法规则

、不能创建新运算符

、不能重载下面的运算符 sizeof ； . 成员运算符； .* 成员指针运算符 ; :: 作用域解析运算符 ？： 条件运算符 ...

关于操作符重载补充[2020年2月19日]
1、上面的操作方式都是函数返回值，对于+=操作函数定义为返回引用

//如果要为类重载运算符，并将非类的项作为其第一个操作数，可以用友元函数来反转操作数顺序

Time operator * (double m, const Time & t) {

    return t * m;

}

常用的友元：重载<<运算符

fried ostream & operator<<(ostream & os, const Time & t）;//返回是ostream引用

 ostream & operator<<(ostream & os, const Time & t) {

    os << t.hours << " hours, " << t.minutes << " minutes";

    return os;

 }

----------------------------

重载运算符：

、成员函数：一个操作数通过this指针隐式地传递，另一个操作数作为函数参数显式地传递

、对于友元版本来说，两个操作数都作为参数传递

枚举： 枚举介绍

enum weekday {sun, mod, tue, wed, thu, fri, sat}; //枚举值是常亮不可以更改

weekday a, b, c; // 三个枚举变量

a = sun;  //a = 0

b = mod;  // b = 1

c = tue;   //  c = 2

随机数的理解
头文件<cstdlib>
rand()是生成随机数的函数，但是随机数的生成时根据一个种子来递推出一系列的数，在使用rand()是默认种子值是1，所以运行两次发现结果一样，故rand()被称为伪随机数，为了是随机数贴近于我们想要的， 需要改变那个种子，所以又有一个srand()函数，参数是种子值，整型，一般用 
srand( (int) time(NULL) )
time()  
time()：此函数会返回从公元 1970 年1 月1 日的UTC 时间从0 时0 分0 秒算起到现在所经过的秒数。如果t 并非空指针的话，此函数也会将返回值存到t 指针所指的内存。

//当构造函数只接受一个参数时，可以用下面格式初始化类对象

Stonewt incognito = ;  // 直接用一个整数初始化，

// 转换函数

operator typeName(); // typeName 是类型

如： operator double ();

、转换函数必须是类方法

、转换函数不能指定返回类型

、转换函数不能有参数

//最好使用显示转换，避免隐式转换

--------------------------------------------

转换函数与友元函数

Stonewt Stonewt::operator+(const Stonewt & st) const { //成员函数

    double pds = pounds + st.pounds;

    Stonewt sum (pds);

    return sum;

}

Stonewt operator+(const Stonewt & st1, const Stonewt & st2) { //友元函数

    double pds = st1.pounds + st2.pounds;

    Stonewt sum(pds);

    return sum;

}

如果提供了Stonewt（double)构造函数：

Stonewt jennySt(,);

double kennyD = 21.12;

Stonewt total;

total = jennySt + kennyD; // 两种函数都可以

total = kennyD + jennySt; // 成员函数则不可以,因为只有类对象才可以调用成员函数，C++不会试图将pennyD转换成Stonewt对象。将对成员函

数参数进行转换，而不是调用成员函数的对象

经验：将加法定义为友元可以让程序更容易适应自动类型转换。

、复制构造函数：新建一个对象并将其初始化为同类的现有的对象时，复制构造函数将被调用。按值传递对象将调用复制构造函数，因此应该用引用传递对象

、默认复制构造函数功能：逐个复制非静态成员的值，

class StringBad {

private:

    char * str;

    int len;

    static int num_strings;

    ...

}

使用默认复制构造函数时，复制的不是字符串，而是一个指向字符串的指针。当析构函数被调用时，这将引发问题。析构函数StringBad释放str指针指向的内存

解决方案：定义一个显式复制构造函数

StringBad::StringBad(const StringBad & st) {

    num_strings++;

    len = st.len;

    str = new char [len + ];

    std::strcpy(str, st.str);

}

//如果类中包含了使用new初始化的指针成员，应当定义一个复制构造函数，以复制指向的数据，而不是指针，这被称为深度复制。

赋值运算符：将已有的对象赋给另一个对象时，将使用重载的赋值运算符。

初始化对象时，并不一定会使用赋值运算符。

与复制构造函数相似，赋值运算符的隐式实现也对成员进行逐个复制。但静态数据成员不受影响。

显式赋值运算符重载：

StringBad & StringBad::operator= (const StringBad & st) {

    if ( this == &st)   // 自身赋值直接返回

        return *this;

    delete [] str;     // 将原有的空间释放，然后在申请要赋值的空间。

    len = str.len;

    str = new char[len + ];

    std::strcpy(str, st.str);

    return *this;

}

、构造函数使用new来初始化指针成员，则应该在析构函数中使用delete

、new和delete必须相互兼容，new对应delete,new[]对应delete[]

、如果有多个构造函数，则必须以相同的方式使用new，要么带中括号，要么都不带，因为只有一个析构函数，所有的构造函数都必须和他兼容

、返回指向const对象的引用

const Vecotr & Max ( const Vector & v1, const Vector & v2) {

    if (v1.magval() > v2.magval())

        return v1;

    else

        return v2;

}

// 返回引用不会调用复制构造函数，效率高；引用指向的对象应该在调用函数执行时存在；v1和v2为const，所以返回类型必须为const

、返回指向非const对象的引用

 比如赋值运算符重载 和 与cout一起使用的<<运算符重载

、返回对象

Vector Vector::operator+(const Vector & b) const {

     return Vector(x + b.x, y + b.y);

}

//在这种情况下，存在调用赋值构造函数来创建被返回的对象开销

、返回const对象

前面中 force1 + force2 = net 是允许的，复制构造函数将创建一个临时变量来表示返回值，因此表达式force1 + force2的结果为一个临时对象。net被赋给该临时对象，使用完临时对象，将他丢弃。

如果将Vecotor::operator+()的返回类型被声明为const Vector, net = force1 + force2,仍然合法， force1 + force2 = net不合法

对象是不能直接调用私有成员变量的，然而写的运算符重载函数中，通过对象却可以调用私有成员

原因：封装是编译期的概念，是针对类型而非对象的，在类的成员函数中可以访问同类型实例对象的私有成员变量．

1、声明指向类对象的指针： String * glamour;

2、将指针初始化为指向已有的对象： String * first = & saying[0]

3、使用new来初始化指针，这将创建一个新的对象：String * favorite = new String (saying[choice])

4、对类嗲用相应的类构造函数来初始化新建的对象

String * gleep = new String;

String * glop = new String ("my my my");

--------------------------------------------

再谈定位new运算符：

    char * buffer = new char[BUF];

    JustTesting *pc1, *pc2;

    pc1 = new (buffer) JustTesting;

    pc3 = new (buffer + sizeof (JustTesting)) JustTesting("Better Idea", 6);

    pc3->~JustTesting();

    pc1->~JustTesting();

    delete [] buffer;

//只有显式调用析构函数，否则不会自动调用析构函数；

//对于使用定位new运算符创建的对象，应以创建顺序相反的顺序进行删除，原因在于，晚创建的对象可能依赖于早创建的对象。仅当所有的对象都被销毁后，才能释放用于存储这些对象的缓冲区。

继承格式：

class RatedPlayer : public TableTennisPlayer { //

private:

public:

    RatePlayer (unsigned int r = , const string & fn = "", const string & ln = "none", bool ht = false);

    RatePlayer (unsigned int r = , TableTennisPlayer & tp);

}

// 派生类的构造函数先执行基类的构造函数，然后在执行派生类的构造函数

RatedPlayer::RatedPlayer(unsigned int r, const string & fn, const string & ln, bool ht) : TableTennisPlayer (fn, ln, ht)

{

    rating = r;

}

RatedPlayer::RatedPlayer(unsigned int r, const TableTennisPlayer & tp) : TableTennisPlayer(tp), rating(r) {}

-----------------------------------------------------------------------------

派生类和基类之间的特殊关系：

、派生类对象可以使用基类的方法，条件是方法不是私有的

、基类指针可以在不进行显式类型转换的情况下指向派生类对象；

、基类引用可以在不进行显式类型转换的情况下引用派生类对象

然而基类指针或者引用只能调用基类的方法，不能调用派生类的方法

基类引用定义的函数或指针参数 可以用于基数对象或者派生对象
void Show(const TableTennisPlayer & rt) // 基类的引用
Show（player1）; // 基类对象引用
Show (rplayer1); //派生类对象的引用
---------------------------------------
将基类对象初始化为派生类对象

RatedPlayer olaf1(1840, "Olaf", "Loaf", true);
TableTennisPlay olaf2(olaf1); // 初始化olaf2，使用隐式复制构造函数 TableTennisPlayer (const TableTennisPlayer &) ,形参是基类的引用

、希望同一个方法在派生类和基类中的行为时不同的。换句话来说，方法的行为应取决于调用该方法的对象。这种复杂的行为成为多态。两种重要的机制可以用于实现多态共有继承机制  在派生类中重新定义类的方法  使用虚函数

---------------------------------------------------------

静态联编和静态联编

联编：将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编

静态联编：C++中编译器查看函数参数以及函数名才能确认使用哪个函数，然而C/C++编译器可以再编译过程完成这种联编。

动态联编：编译器必须生成能都在程序运行是选择正确的虚方法的代码这被称为动态联编

--------------------------------------------------------------------------

指针和引用类型的兼容性

基类指针或者引用转换为派生类指针或者引用 如果不使用显式类型转换是不允许的，对于派生类的新类成员函数不能用于基类

--------------------------------------------------------------

编译器对非虚方法使用静态联编， 直接根据指针类型调用方法，指针类型在编译时已知；总之编译器对非虚方法只用静态编联

虚函数是根据对象类型调用，只有在运行是才能确认对象类型，编译器生成的代码将在程序执行，将方法关联， 编译器对虚方法使用动态编联。

----------------------------------------------------------------------

虚函数的工作原理：

为每个对象添加一个隐藏成员，隐藏成员中保存了指向函数地址数组的指针，该数组被称为虚函数表。虚函数表中存储着类对象进行声明的虚函数地址。 如果派生类重新定义了虚函数，则保存新函数地址，否则保存原始的函数地址，就是基类的；

调用虚函数，程序查看存储在对象中的 虚函数表地址，

每个对象都要增加存储（函数表地址）地址的空间； 每个类还要创建虚函数地址表； 每个函数调用还要执行一项额外的操作，即到表中查找地址

-------------------------------------------------------------------------

虚函数注意事项：

、构造函数能不是虚函数

、析构函数应当是虚函数，这样派生类根据自己的情况来析构

、友元不能使虚函数，友元不是类成员，只有成员才能使虚函数

、没有重新定义将使用该函数的基类版本

、重新定义 不会生成函数两个重载版本，重新定义继承的方法不是重载，

    如果重新定义继承的方法，应确保与原来的原型完全相同，但如果返回类型是基类引用或指针，可以修改派生类的引用或指针，这种类型被称为返回类型协变，返回类型随类 类型的变化而变化。

   如果基类声明被重载了，则应该在派生类重新定义所有的基类版本，如果只重新定义一个版本，则另两个版本将被隐藏，派生类对象无法使用它们

含有未实现的方法：包含纯虚函数的类叫做抽象基类

-----------------------------------------

继承和动态内存分配：

第一种情况：派生类不使用new；

不需要定义显示析构函数，赋值构造函数和赋值运算符

对于析构函数：编译器定义一个不执行任何操作的默认析构函数，然后 调用基类析构函数；

对于赋值构造函数 和 赋值函数，直接调用基类显式然后，执行自己默认的复制

第二种情况：派生类使用new;

三种都需要

class baseDMA

{

private:

    char * label;

    int rating;

public:

    baseDMA(const char * l = "null", int r = );

    baseDMA(const baseDMA & rs);

    virtual ~baseDMA();

    baseDMA & operator= (const baseDMA & rs);

    friend std::ostream & operator<<(std::ostream & os, const baseDMA & rs);

};

class lacksDMA : public baseDMA

{

private:

    enum {COL_LEN =  };

    char color[COL_LEN];

public:

    lacksDMA(const char * c = "black", const char * l = "null", int r = );

    lacksDMA(const char * c, const baseDMA & rs);

    friend std::ostream & operator<<(std::ostream & os, const lacksDMA & rs);

};

class hasDMA : public baseDMA

{

private:

    char * style;

public:

    hasDMA(const char * s = "none", const char * l = "null", int r = );

    hasDMA(const char * s, const baseDMA & hs);

    hasDMA(const hasDMA & hs);

    ~hasDMA();

    hasDMA & operator=(const hasDMA & rs);

    friend std::ostream & operator<<(std::ostream & os, const hasDMA & rs);

};

hasDMA & hasDMA::operator=(const hasDMA & hs)

{

    if (this == &hs)

        return *this;

    baseDMA::operator=(hs); // 调用hs，然会this指针

    delete [] style;

    style = new char[std::strlen(hs.style) + ];

    std::strcpy(style, hs.style);

    return *this;

}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs)

{

    os << (const baseDMA &) hs;  // 直接输出基类的对象，然后在输出派生类特有的

    os << "Style: " << hs.style << std::endl;

    return os;

}

#include <valarray>

valarray<int> q_values(; // 8个整形

valarray<double> weights;

valarray<double> v4(gpa, ); //v4含有4个元素，用gpa前四个初始化

--------------------------

方法：

operator[]() //访问各个元素

size() // 返回包含元素数

sum() // 返回所有元素的总和

max() // 返回最大元素

min()  // 返回最小元素

cout是ostream类的对象，其中有方法为put() 和 write()，

put方法原型： ostream & put(char) //返回指向调用对象的引用

cout.put('l').put('o'); // 只是允许的

write方法是显示整个字符串，第一个参数提供字符串地址，第二个参数指出要显示多少字符，返回类型ostram&

cout.write(taste, len + ); 即使比taste长度多，也要显示len + 5个

、修改显示时使用的计数系统

十进制：dec, 十六进制：hex，八进制：oct

hex(cout) 或者 cout << hex 等价

、调整字段宽度

int width();

int width(int i);

cout.width() // 设置宽度为8，width（）方法只影响接下来显示的一个项目，然后字段宽度将恢复为默认值

cout.fill(‘*’)设置填充字符 一直有效

-----------------------------------------------------------------------------

、设置浮点数精度

在默认情况下，指的是显示的总位数

cout.precision();

//对于小数来说显示总位数为2；

、打印末尾的0和小数点

ios_base类提供了一个setf()函数，能够控制多种格式化特性。这个类还定义了多个常量，可用作该函数的参数

cout.setf(ios_base::showpoint) // 使cout显示末尾的小数点

cout.precision();

如果整数部分正好两位，还要显示一个小数点

-------------------------------------

再谈setf()

setf()函数有两个原型。第一个为 fmtflags setf (fmtflags);

    int temperature = ;

    cout.setf(ios_base::showpos); // 在正数前面加+号，只有基数为10时才加

    cout << hex; // 十六进制

    cout.setf(ios_base::uppercase); // 对于16进制输出， 使用大写字母

    cout.setf(ios_base::showbase); //对于输出，使用基数前缀（0,0x)

    cout << temperature << endl;

    cout.setf(ios_base::boolalpha); // 输出bool值，可以为true或false

    cout << true << endl;

-----------------------------------------------------------------

第二个setf()原型接受两个参数，并返回以前的设置

fmtflags setf(fmtflags, fmtflags);

    cout.setf(ios_base::left, ios_base::adjustfield); //使用左对齐

    cout.setf(ios_base::showpos);

    cout.setf(ios_base::showpoint);

    cout.precision();

    ios_base::fmtflags old = cout.setf(ios_base::scientific, ios_base::floatfield); // 科学计数法，此时精度是指小数点后面的位数

    for (int n = ; n <= ; n += )

    {

        cout.width();

        cout << n << "|";

        cout.width();

        cout << sqrt(double (n)) << "|\n";

    }

    cout.setf(ios_base::internal, ios_base::adjustfield); // 符号或基数前缀左对齐，值右对齐

    cout.setf(old, ios_base::floatfield); // 恢复之前，此时精度就是总的位数

    cout << "Internal Justification:\n";

    for (int n = ; n <= ; n += )

    {

        cout.width();

        cout << n << "|";

        cout.width();

        cout << sqrt(double(n)) << "|\n";

    }

    cout.setf(ios_base::right, ios_base::adjustfield);

    cout.setf(ios_base::fixed, ios_base::floatfield); //定点计数法

    for (int n = ; n <= ; n += )

    {

        cout.width();

        cout << n << "|";

        cout.width();

        cout << sqrt(double(n)) << "|\n";

    }