c++ 命名空间 namespace

命名空间要解决不同代码部分之间的命名冲突的问题。

举个例子来说明吧！为了让同名函数能调用，我们采取的是将函数重载的方法，而另外的解决放方法就是把不同的函数放在不同的命名空间里，调用时只需要告诉系统要调用在哪个命名空间即可！

能放在命名空间里的不仅是函数，我觉得什么都可以！

（一）命名空间的用法

看完这个例子就知道命名空间怎么用了！在命名空间里Records 里放了一个类，以及类中成员函数的实现！

namespace Records //Records是命名空间名，可以随便命名

{

  内容

}

  Records 里放什么都可以只要c++允许，像类，结构体，变量等！

看完这个例子就知道命名空间怎么用了！在命名空间里Records 里放了一个类，以及类中成员函数的实现！

#include <iostream>

using namespace std;

namespace Records 

 {

  const int kDefaultStartingSalary = 30000;

  class Employee

    {

    public:

      Employee();

      void     promote(int inRaiseAmount = 1000);

      void     demote(int inDemeritAmount = 1000);

      void     hire();     // hires or re-hires the employee

      void     fire();     // dismisses the employee

      void     display();  // outputs employee info to the console

      // Accessors and setters

      void          setFirstName(std::string inFirstName);

      std::string   getFirstName();

      void          setLastName(std::string inLastName);

      std::string   getLastName();

      void          setEmployeeNumber(int inEmployeeNumber);

      int           getEmployeeNumber();

      void          setSalary(int inNewSalary);

      int           getSalary();

      bool          getIsHired();

    private: 

      std::string   mFirstName;

      std::string   mLastName;

      int           mEmployeeNumber;

      int           mSalary;

      bool          fHired;

    };

  Employee::Employee()

  {

    mFirstName = "";

    mLastName = "";

    mEmployeeNumber = -1;

    mSalary = kDefaultStartingSalary;

    fHired = false;

  }

  void Employee::promote(int inRaiseAmount)

  {

    setSalary(getSalary() + inRaiseAmount);

  }

  void Employee::demote(int inDemeritAmount)

  {

    setSalary(getSalary() - inDemeritAmount);

  }

  void Employee::hire()

  {

    fHired = true;

  }

  void Employee::fire()

  {

    fHired = false;

  }

  void Employee::display()

  {

    cout << "Employee: " << getLastName() << ", " << getFirstName() << endl;

    cout << "-------------------------" << endl;

    cout << (fHired ? "Current Employee" : "Former Employee") << endl;

    cout << "Employee Number: " << getEmployeeNumber() << endl;

    cout << "Salary: $" << getSalary() << endl;

    cout << endl;

  }

  // Accessors and setters

  void Employee::setFirstName(string inFirstName)

  {

    mFirstName = inFirstName;

  }

  string Employee::getFirstName()

  {

    return mFirstName;

  }

  void Employee::setLastName(string inLastName)

  {

    mLastName = inLastName;

  }

  string Employee::getLastName()

  {

    return mLastName;

  }

  void Employee::setEmployeeNumber(int inEmployeeNumber)

  {

    mEmployeeNumber = inEmployeeNumber;

  }

  int Employee::getEmployeeNumber()

  {

    return mEmployeeNumber;

  }

  void Employee::setSalary(int inSalary)

  {

    mSalary = inSalary;

  }

  int Employee::getSalary()

  {

    return mSalary;

  }

  bool Employee::getIsHired()

  {

    return fHired;

  }

}

int main ()

{

  cout << "Testing the Employee class." << endl;

 Records::Employee emp;

  emp.setFirstName("Marni");

  emp.setLastName("Kleper");

  emp.setEmployeeNumber(71);

  emp.setSalary(50000);

  emp.promote();

  emp.promote(50);

  emp.hire();

  emp.display();

 return 0;

}

在调用命名空间里的内容要加上（命名空间名：：），这里要将类Employee实例化，就是采用的 Records::Employee emp，建立了对象emp；

（二）命名空间的嵌套

命名空间的嵌套使用的最多的还是作用域运算符，告诉系统要调用的在那个命名空间里嵌套的命名空间里能找到要调用内容！

下面举一个实例，我相信大家一看就会明白！

在命名空间之外定义函数，函数返回类型如果是自定义类型的，必须使用命名空间的限定修饰；同时，函数名同样需要这种限定修饰。但是对于函数参数表和函数体内部的命名空间成员名字都可以使用简短形式。

#include <iostream>

using namespace std;

namespace myspace1 

{

double const PI=3.14;

double nval1(1.2),nval2(1.3);

double max(double x, double y);

 

namespace myspace2   //在命名空间myspace1内定义命名空间myspace2

{

double multi(double x);

double division(double x)

{

return PI/x; 

}

}

}

int main() 

{

    cout<<“please input two integer:”;

    cin>>myspace1::nval1>>myspace1::nval2;

    cout<<“the maxnum is”<<myspace1::max(myspace1::nval1,myspace1::nval2)<<endl;

    cout<<“the accumulation is :”<<myspace1::myspace2::multi(myspace1::nval1)<<endl;//使用命名空间里嵌套的命名空间

    cout<<"the quotient is:”<<myspace1::myspace2::division(myspace1::nval2)<<endl;

}

 

double myspace1::max(double x,double y) 

{

    return x>y?x:y;

}

 

double myspace1::myspace2::multi(double x) 

{

    return PI*x; 

}

相信通过这个例子可以大家可以知道命名空间的嵌套是怎么用的！

谢谢各位看客看我写的内容，因为你的阅读每次都促进我不断写更好的内容和大家一起分享，要知道你是我成长的动力！