C++的对C的扩展(1)

C++的对C的扩展

• 1、::作用域运算符
• 2、命名空间 namespace 解决命名冲突
• • 2.1 namespace命名空间的定义
  • 2.2 命名空间只能在全局范围内定义（**以下写法错误**）
  • 2.3 命名空间可以嵌套命名空间
  • 2.4 命名空间时开放的，即可以随时把新的成员加入已有的命名空间中（常用）
  • 2.5 命名空间可以存放变量和函数
  • 2.6 命名空间中的函数 可以在“命名空间”外定义
  • 2.7 无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于这个标识符加上了static，使得其可以作为内部连接（了解）
  • 2.8 给命名空间取个别名（了解）
• 3、using使用命名空间
• • 3.1 简化了从命名空间的成员访问
  • 3.2 using使用整个命名空间
  • 3.4 using指明使用具体的命名空间成员。（了解）
  • 3.5 using声明碰到函数重载（了解）
  • 3.6 不同命名空间中的同名成员使用的时候注意二义性

1、::作用域运算符

#include 

using namespace std;
int a = 10;
void test01(){
    int a = 20;
    cout << "局部变量a=" << a << endl;
    cout << "全局变量a=" << ::a << endl;
}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

2、命名空间 namespace 解决命名冲突 2.1 namespace命名空间的定义

namespace A {
    int a = 10;
}
namespace B {
    int a = 20;
}

void test02(){
    cout << "A中a=" << A::a << endl;
    cout << "B中a=" << B::a << endl;
}
int main(int argc, char *argv[])
{
    test02();
    return 0;
}

2.2 命名空间只能在全局范围内定义（以下写法错误）

void(){
	namespace A {
    int a = 10;
	}
	namespace B {
    int a = 20;
	}
	cout << "A中a=" << A::a << endl;
    cout << "B中a=" << B::a << endl;
}

2.3 命名空间可以嵌套命名空间

namespace A {
    int a = 10;
    namespace C {
         int a = 10;
    }
}
void test03(){
    cout << "A中a=" << A::a << endl;
    cout << "C中a=" << A::C::a << endl;
}
int main(int argc, char *argv[])
{
    test03();
    return 0;
}

2.4 命名空间时开放的，即可以随时把新的成员加入已有的命名空间中（常用）

namespace A {
    int a = 10;
    namespace C {
         int a = 20;
    }
}
//将c添加到命名空间A中
namespace A {
     int b = 10;
}

2.5 命名空间可以存放变量和函数

namespace A {
    int a = 10;
    namespace C {
         int a = 20;
    }
    void func(){
        cout << "命名函数中存放函数"<
   cout << "A中a=" << A::a << endl;
   A::func();
}

int main(int argc, char *argv[])
{
    test03();
    return 0;
}

2.6 命名空间中的函数 可以在“命名空间”外定义

namespace A {
    int a = 10;
    namespace C {
         int a = 20;
    }
    void func();
}
//访问命名空间的数据不用加作用域
void A::func(){
    cout << "a=" << a << endl;
}
void test04(){
   A::func();
}

int main(int argc, char *argv[])
{
    test04();
    return 0;
}

2.7 无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于这个标识符加上了static，使得其可以作为内部连接（了解） 2.8 给命名空间取个别名（了解）

namespace veryLongName {
    int a = 10;
    namespace C {
         int a = 20;
    }
    void func(){
    cout << "a=" << a << endl;
}
}
void test(){
	namespace shortName = veryLongName;
	cout << "veryLongName :: a" <<  shortName::a << endl;
	//起别名之后，原名称与别名皆可使用
	shortName::func();
	veryLongName::func();
}

3、using使用命名空间 3.1 简化了从命名空间的成员访问

namespace A {
    int a = 10;
    namespace C {
         int a = 20;
    }
    void func();
}
void test05(){
    //使用A命名空间
    using namespace A;
    //使用的变量首先从命名空间中找，找不到的话，再从其他地方找。
    cout << "a=" << a << endl;
}

int main(int argc, char *argv[])
{
    test05();
    return 0;
}

3.2 using使用整个命名空间

namespace veryLongName {
    int a = 10;
    namespace C {
         int a = 20;
    }
    void func(){
        cout << "命名空间中存放函数"<
    int a = 15;
    using namespace veryLongName;
    cout << a << endl;//访问的是局部变量中的a
    cout << veryLongName::a << endl;//访问的是veryLongName中的a
}
int main(int argc, char *argv[])
{
    test07();
    return 0;
}

using使用整个命名空间会和全局变量冲突

3.4 using指明使用具体的命名空间成员。（了解）

using直接使用命名空间中的成员会和局部变量冲突

using直接使用命名空间中的成员会和局部变量冲突

int a = 15;
namespace veryLongName {
    int a = 10;
    namespace C {
         int a = 20;
    }
    void func(){
        cout << "命名空间中存放函数"<
    using veryLongName :: a;
    cout << a << endl;
    //cout << veryLongName::a << endl;//访问的是veryLongName中的a
}
int main(int argc, char *argv[])
{
    test08();
    return 0;
}

3.5 using声明碰到函数重载（了解）

namespace A {
   void func(){
       cout << "无参的函数" <
      cout << "只有一个参数的函数" <
       cout << "有两个参数的函数"<
    //using指明会对所有的func起作用
    using A::func;
    func();
    func(10);
    func(10,15);

}
int main(int argc, char *argv[])
{
    test09();
    return 0;
}

3.6 不同命名空间中的同名成员使用的时候注意二义性

总结：

1. 命名空间的含义（不能在函数内定义命名空间）
2. 使用命名空间的成员最安全的方式 命名空房名::成员名
3. using namespace 命名空间名；（使用整个命名空间）

 using namespace A；

4. 单独使用命名空间中的具体成员：using 命名空间名::成员名；

using A::a;