这是关键字。他的定义在C++标准里，不是在头文件里：）

之前那个问题，visual 2008好像解决了，但程序就是没有结果，麻烦看一下！[code=c]
请填写代码
[/code]
#include <iostream>
#include <string>
#include <cstdlib>
/*本程序是用户输入婚否和收入，计算并打印税后余额
*/
using namespace std;

const double RATE1=0.15;  //三个税率
const double RATE2=0.28;
const double RATE3=0.31;

class Tax
{
public:
       Tax(int x,double y); //构造函数
       double marred();     //已婚交税
       double unmarred();   //未婚交税
       void judge();        //判断婚否
       void print();        //打印税后余额
private:
       int  marry;
       double income;
       double after_income;
};
Tax::Tax(int x,double y)
{
     marry=x;
     income=y;
     after_income=0;
     cout<<"初始化成功！"<<endl;

}
void Tax::judge() 
{
    if(marry==0)       //0代表未婚
        unmarred();
    else
        if(marry==1)   //1代表已婚
            marred();
}
double Tax::unmarred()
{
    if(income<=21450)
        after_income=income*(1-RATE1);
    if(income>21450&&income<=51900)
        after_income=income*(1-RATE2);
    else
        after_income=income*(1-RATE3);
    return after_income;
}
double Tax::marred()
{
    if(income<=35800)
        after_income=income*(1-RATE1);
    if(income>35800&&income<=86500)
        after_income=income*(1-RATE2);
    else
        after_income=income*(1-RATE3);
    return after_income;
}
void Tax::print()
{
    cout<<"Your income after tax is:"<<after_income;
}

int main()
{
    int x;
    double y;
    cout<<"If you hava marred ,fill 1 else fill 0: ";//输入婚否，0为否，1为已婚
    cin>>x;
    cout<<"\n"<<"OK,and then fill your income:";//输入收入
    cin>>y;
    Tax* example=new Tax(x,y);
    example->judge();
    example->print();
    return 0;


}

// .h file

#ifndef main_h__
#define main_h__

#include <iostream>
using namespace std;

class Tax
{
public:
    Tax(double val)
        : _income(val) {};
    ~Tax() {};
    virtual void print() = 0;
protected:
    static const double RATE1;//=0.15;  //三个税率
    static const double RATE2;//=0.28;
    static const double RATE3;//=0.31;
    double _income;
private:
};

class unmarred_Tax : public Tax
{
public:
    unmarred_Tax(double val)
        : Tax(val) {};
    ~unmarred_Tax();
    virtual void print();
protected:
    
private:
};

class marred_Tax : public Tax
{
public:
    marred_Tax(double val)
        : Tax(val) {};
    ~marred_Tax();
    virtual void print();
protected:
    
private:
};

inline void unmarred_Tax::print() 
{
    std::cout << "unmarred after tax income : " << (_income <= 21450 ? _income*(1-Tax::RATE1) : 
(_income <= 51900 ? _income*(1-Tax::RATE2) : 
_income*(1-Tax::RATE3))) << std::endl;
}

inline void marred_Tax::print()
{
    std::cout << "marred after tax income : " << (_income <= 35800? _income*(1-Tax::RATE1) : 
(_income <= 86500? _income*(1-Tax::RATE2) : 
_income*(1-Tax::RATE3))) << std::endl;

}

#endif // main_h__

// .cpp file


#include <cstdlib>
#include <iostream>
#include "main.h"


const double Tax::RATE1 = 0.15;
const double Tax::RATE2 = 0.28;
const double Tax::RATE3 = 0.31;

int main()
{
    using namespace std;

    Tax* pmTax = new unmarred_Tax(5000);
    Tax* punmTax = new marred_Tax(12000);

    pmTax->print();
    punmTax->print();

    delete pmTax;
    delete punmTax;

    double income;
    cout << "Enter income: ";
    cin >> income;

    Tax* pTax = new unmarred_Tax(income);
    pTax->print();

    delete pTax;
        
    system("pause");
    return EXIT_SUCCESS;
}
这么做。

谢谢，你的修改也可以！我在最后加上了system("PAUSE");也还是可以了

[quote]
谢谢，你的修改也可以！我在最后加上了system("PAUSE");也还是可以了[/quote]
我估计你没真的搞明白我的做法和你的做法的差别。如果作为类型域的方案，你的做法也是有问题的。构造函数中带标识是个下下策。而动态绑定是解决类似问题的好办法。绝不仅仅是什么system("pause")。

你好，我刚才仔细分析了一下，虽然也还有很多地方看不懂，大致你是分了.h 域和.cpp域，然后是放在头文件和资源文件里编译。之前是没懂，才自学，见谅啊！只不过怎样构造头文件我还没怎么学，那个不太懂。我常遇见那些很傻的问题，可以请教你吗？

[quote]
你好，我刚才仔细分析了一下，虽然也还有很多地方看不懂，大致你是分了.h 域和.cpp域，然后是放在头文件和资源文件里编译。之前是没懂，才自学，见谅啊！只不过怎样构造头文件我还没怎么学，那个不太懂。我常遇见那些很傻的问题，可以请教你吗？[/quote]
说的神马？什么.h域，不是扯么。.h是头文件，域什么呢。
类型域是这么个意思，如果需要区分marred和unmarred是不同的类型，而又同属于tax，那么还有种方案是这样的。
class Tax
{
public:
    enum Tax_type {MARRED, UNMARRED};
    Tax_type _type;
    Tax(Tax_type type, const double income)
        : _type(type), _income(income) {};
    ~Tax() {};
    double _income;
    static const double rate1;
    static const double rate2;
    static const double rate3;
};

还得需要一个function
void print_tax(const Tax* pT)
{
    switch (pT->_type)
    {
    case Tax::UNMARRED:
        std::cout << "unmarred after tax income : " << (pT->_income <= 21450 ? pT->_income*(1-Tax::rate1) : 
        (pT->_income <= 51900 ? pT->_income*(1-Tax::rate2) : 
         pT->_income*(1-Tax::rate3))) << std::endl;
        break;
    case Tax::MARRED:
        std::cout << "marred after tax income : " << (pT->_income <= 35800? pT->_income*(1-Tax::rate1) : 
        (pT->_income <= 86500 ? pT->_income*(1-Tax::rate2) : 
         pT->_income*(1-Tax::rate3))) << std::endl;
    }
}

最后，是main()
int main(int argc, char **argv, char **env)
{
    Tax t1(Tax::MARRED, 12000);
    Tax t2(Tax::UNMARRED, 35000);
    print_tax(&t1);
    print_tax(&t2);

    return EXIT_SUCCESS;
}

这样就可以区分出来，你可以对比下上面的virtual member function的方式，显然更好。
而你的judge()判断，有个致命的问题，如果在是否已婚，输入3，4，dkfnk,......怎么办呢？ 程序处于无定义状态。对吧，对比一下。:)

我有的时候编程就是这样，不懂得在程序和用户之间怎么协调。我原来的想法就是让用户自己输入婚否和收入，但这样又使得程序不稳定。能给出一些建议吗？

我是学软件的，才学！可以加你的QQ吗？你下次同意了我才加，我的是643444070，你也可以加我。我觉得你还挺负责的，给我讲了这么多，谢谢！而且很厉害，像那个指针和析构函数我就不懂，还没仔细看。

库里面！！