是书中的原话，说起这本书，我真是够了，翻译很差劲，好多地方有错字，意思和事实相反的比比皆是，不知道是不是买到盗版了......

12.多文件的组织
一般的程序可以被分为三部分：
头文件：包含结构声明和使用这些结构的函数的原型
源代码文件：包含与结构有关的函数的代码
源代码文件：包含调用与结构有关的函数的代码

头文件常包含的内容：
函数原型
使用#define或const定义的符号常量
结构声明
类声明
模版声明
内联函数

13.静态持续变量：

    ......
    int global = 1000;//静态持续，外部链接(可在其他文件中访问)
    static int one_file = 50;//静态持续，内部链接(只在当前文件中访问)
    int main()
    {
        ....
    }
    void funct1(int n)
    {
        static int count = 0;//静态持续，无链接
    }
    //所有类型的静态持续性变量在整个程序执行期间都存在,未被初始化的将被设置为0
    void funct2(int q)
    {
        ........
    }
    ........

使用其他文件中的全局变量的方法：

//file01.cpp
int blem;
int main()
{
    ......
}
//file02.cpp
extern int blem;//不能对其初始化，否则为重新定义变量，extern关键字失效
.....

[此贴子已经被作者于2016-1-21 16:51编辑过]

c++入门书籍推荐，
plus合适还是primer，有的推荐 c++程序设计原理与实践，版主推荐推荐，

不好说了这个，任何一本书只要是关于C++的，差不多都能让你入C++的门，但能让你精通C++的书还是要好好选的，网上也有关于各种书的评论，你可以自己看看。其他书我没读过，目前我学的这本对我来说够用了，也不难懂。PS：我也是新手

14. this指针：
在类中，每个成员函数都有一个this指针，包括构造函数和析构函数，this指针指向用来调用成员函数的对象。如，对于类对象stock1和stock2,stock1.topval(stock2)是stock1对象的成员函数topval显式调用了对象stock2,此时topval函数的this指针指向stock1。
15.创建友元
创建友元函数：在类声明中放入原型，在原型前加上关键字friend,这意味着友元函数不是成员函数，不能使用成员算魏符来调用，但它有与成员函数相同的访问权限。为类重载二元算符时常常用到友元，比如一个时间类与一个实数相乘时，对于时间类对象A和B，A+B或A-B运算中左侧A为调用对象，其表达式相当于A.operater+(B)和A.operater-(B)，但这种方法用于时间类与实数相乘则会出现问题，因为A*2.75应该与2.75*A应该相同，但2.75*A不对应任何成员函数，2.75并不是对象，解决这个问题的一种方式便是非成员函数，它不由对象调用，且总是使用显式参数。

[此贴子已经被作者于2016-3-8 16:05编辑过]

16.常用的友元：重载<<运算符
<<实际上已经被重载过很多次了，最初它是C和C++的位运算符，将值中的位左移，ostream类对该运算符进行了重载，将其作为一个输出工具，cout是一个ostream对象，它是智能的，能够识别所有的C++基本类型，这是因为对于每一种基本类型，ostream类声明中都包含了相应的重载operator<<()定义。要使cout能识别自定义类的对象，一种可行的办法就是通过类声明让类知道如何使用cout。
1）第一种重载版本：
要使Time类知道使用cout，必须使用友元类，因为可以像下面这样的语句使用两个对象:
cout<< <对象名>;//这正是我们想要的
而如果使用一个类成员函数重载<<，则调用方式将变成<对象名><<cout;这会令人迷惑。

//<<重载：
#include<iostream>
#include<ostream>
#include<iomanip>
using namespace std;
class Time
{
private:
    int hours;
    int minutes;
public:
    friend ostream& operator<<(ostream& os,const Time &t);
    Time();
    Time(int,int);
    //void Show()const;
    ~Time();
};
Time::Time()
{
    hours=0;
    minutes=0;
}
Time::Time(int hr,int mns):hours(hr),minutes(mns)
{

}
Time::~Time()
{
    cout<<"析构\n";
}
/*void Time::Show()const
{
    cout<<hours<<":"<<minutes;
}*/
ostream& operator<<(ostream& os,const Time &t)
{
    //os<<setw(2)<<setfill('0')<<t.hours<<":"<<setw(2)<<setfill('0')<<t.minutes;
    os<<setw(2)<<setfill('0')<<t.hours<<":"<<setw(2)<<setfill('0')<<t.minutes;
    return os;
}
int main()
{
    Time time(1,5);
    //time.Show();
    cout<<time<<endl;
    return 0;
}

[此贴子已经被作者于2016-3-8 16:44编辑过]

以上代码已经是正确的重载，分析时，我们可以回到重载的最初过程中来，为了实现基本的自定义对象的输出，可以像下面这样重载运算符：

void operator<<(ostream& os,const Time& t)
{
    os<<setw(2)<<setfill('0')<<t.hours<<":"<<setw(2)<<setfill('0')<<t.minutes;//这样可以使用cout<< <对象名>打印时间对象
}

但这种方法存在的问题是不允许通常那样将重新定义的<<运算符与cout一起使用，比如这样是不行的,对于Time对象t：cout<<t<<"Tuesday\n";
这是因为<<运算符要求左边是一个ostream对象，具体的说，它返回一个指向调用对象本身（一般是cout）的引用，所以对于cout<<x<<y;(cout<<x)的结果是返回一个cout对象，继而可以做cout<<y;而重载的<<运算符无返回类型时，将无法与cout一起使用，因此可以如上楼所示定义重载函数时返回一个指向ostream对象的引用。函数开始执行时已经传入一个引用对象，这样做的最终结果是返回值就是传递给它的对象。
cout<<t;将被转换为operator<<(cout,t);此调用返回cout对象，此时cout<<t<<"Tuesday\n";可以正常工作
这个版本还可以被用来写入到文件：

#include<fstream>
.........
ofstream fout;
fout.open("time.txt");
Time t(1,5);
fout<<t;
.....

重载<<显示c_name对象的一般模式：

ostream& operator<<(ostream& os,const c_name &obj)
{
    os<<.......;
    return os;
}

[此贴子已经被作者于2016-3-8 17:07编辑过]

17.类的定义，常见算符的重载，友元函数存在的意义（之一吧算是）

#include <iostream>
using namespace std;
class complex0{
private:
    double real;
    double img;
public:
    complex0();
    complex0(double,double);
    complex0 operator+(complex0 cp);
    complex0 operator-(complex0 cp);
    complex0 operator~(){complex0 tmp;tmp.real=real;tmp.img=-img;return tmp;};
    complex0 operator*(complex0 cp);
    complex0 operator*(double x);
    ~complex0(){};
    friend ostream& operator<<(ostream& os,const complex0 cplx);
    friend istream& operator>>(istream& is,complex0& cpi);
    friend complex0 operator*(double x,complex0 cp);
};
complex0::complex0()
{
    real=0;
    img=0;
}
complex0::complex0(double r,double i):real(r),img(i)
{

}
istream& operator>>(istream& is,complex0& cpi)
{
    cout<<"real:";
    is>>cpi.real;
    cout<<"img:";
    is>>cpi.img;
    return is;
}
ostream& operator<<(ostream& os,const complex0 cplx)
{
    os<<"("<<cplx.real<<","<<cplx.img<<"i)";
    return os;
}
complex0 complex0::operator+(complex0 cp)
{
    complex0 tmp;
    tmp.real=real+cp.real;
    tmp.img=img+cp.img;
    return tmp;
}
complex0 operator*(double x,complex0 cp)
{
    return cp*x;
}
complex0 complex0::operator-(complex0 cp)
{
    complex0 tmp;
    tmp.real=real-cp.real;
    tmp.img=img-cp.img;
    return tmp;
}
complex0 complex0::operator*(complex0 cp)
{
    complex0 tmp;
    tmp.real=real*cp.real-img*cp.img;
    tmp.img=real*cp.img+img*cp.real;
    return tmp;
}
complex0 complex0::operator*(double x)
{
    complex0 tmp;
    tmp.real=real*x;
    tmp.img=img*x;
    return tmp;
}
int main()
{
    complex0 a(3.0, 4.0); // initialize to (3,4i)
    complex0 c;
    cout << "Enter a complex number (q to quit):\n";
    while (cin >> c)
    {
        cout << "c is " << c << '\n';
        cout << "complex conjugate is " << ~c << '\n';
        cout << "a is " << a << '\n';
        cout << "a + c is " << a + c << '\n';
        cout << "a - c is " << a - c << '\n';
        cout << "a * c is " << a * c << '\n';
        cout << "2 * c is " << 2 * c << '\n';
        cout << "Enter a complex number (q to quit):\n";
    }
    cout << "Done!\n";
    return 0;
}

[此贴子已经被作者于2016-3-30 10:42编辑过]