ubuntu 下 Tor,你懂的

翻墙有风险，带套保平安

我对自己的智力开始表示怀疑了，即使是对着手册一步一步做，为什么还要折腾4个多小时嘞？！

（1）配置源

deb     http://deb.torproject.org/torproject.org <DISTRIBUTION> main

用的是jauty

（2）添加源的认证签名

gpg --keyserver keys.gnupg.net --recv 886DDD89
gpg --export A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89 | sudo apt-key add -
apt-get update
apt-get install tor 

（3）配置privoxy（tor依赖安装的）

$sudo gedit /etc/privoxy/config 

forward-socks4a / 127.0.0.1:9050 . （可以在默认里找到这行，去掉注释）

Privoxy 会记录所有使用它浏览网页而留下的日志文件，如果你不需要保存日志文件，在下面这两行之前输入 “#” 注释掉。

#logfile logfile

#jarfile jarfile

（6）安装vidalia

sudo apt-get install vidalia

 

（5） 为firefox安装Torbutton 插件

解决ubuntu下pdf乱码的问题

sudo apt-get install poppler-data 后 evince中文能显示了



不过繁体中文字体结构仍然奇怪。这是因为evince只要遇到内嵌字体为新明细体或标楷体都会把文字肢解了，所以繁体中文支离破碎了。



xpdf可以显示，但是xpdf界面太丑了，速度感觉也不行。安装了foxit，还不错吧，速度还比evince快。



所以推荐foxit，如果不在意闭源的话。

UPDATE 20111001

evince 安装poppler-data后部分pdf（不是繁体），中文显示为方块,解决方法是：
如果已经安装了文泉驿微米黑字体，
sudo gedit /etc/fonts/conf.d/49-sansserif.conf
将倒数第四行的sans-serif修改为WenQuanYi Micro Hei就可以了。
修改为其他的中文字体名称应该也是可以的。

跟风，ubuntu

今天是犯抽抽了，所以才会再折腾u盘puppy系统未果后，屡败屡战地消磨了一天时间在vs上，最后又热血上头要试试硬盘安装ubuntu.说这最后的决定说是一时冲动，不如说是为了给这荒唐的一天留给自己一点安慰，至少我也装了个ubuntu嘛，虽然这也没啥。

硬盘安装ubuntu，像我这种小菜，无非就是上网搜几个帖子，按图索骥就是了。但即便你握着藏宝图，路还是要自己走的，这就难免有那么点曲折反复，柳暗花明的破事，记之。

1. 在windows下用分区软件分出一个ext3（主分区）和一个swap（扩展分区），留给ubuntu。这里用得不是pq，而是Acronis Disk Director Suite，pq居然连我的u盘都识别不出来，实在是让我失望。按照帖子的方法，grub4dos引导到ubuntu liveCD，从liveCD里安装ubuntu，这时出现的问题是ubuntu无法正确识别分区表，但是用sudo fdisk -l能列出已分好的分区。退回Windows下，用分区软件将ext3的那个分区转为扩展分区，再重新进入liveCD，一切正常。原因嘛..不明。
2. 配置显示器。问题简单的说（其实不简单的说也得这么说）就是ubuntu下分辨率只能保持800*600.Google之,先安装nvidia的驱动（我的主板是nvidia的.....集成显卡，�），在hardware-drivers下自动扫描得到，当然首先得先配置好软件源吧。利用nvidia-settings和nvidia-xconfig（这命令好像会重新写个/etc/X11/xorg.conf），差不多这时就可以出现1024*768啦.但这个分辨率还是不爽，显示得窗口不完全...在nvidia-setting下更改为1280×960，并有按键提示保存到xorg.conf..搞定
3. 准备让ubuntu使用英文locale，一个很现实的问题是还是要输入中文的嘛，这个...显然是装B.安装了en，ch的语言包，并把默认语言设为en。再则就是修改/etc/environment，具体不表。这样就可以在应为locale下尽情地用中文输入法（scim，小企鹅不懂）装B啦。
4. 双系统ubuntu和windows系统时间相差八小时，ubuntu的比较快。我居然发现了，泪流满面。这是因为勒，ubuntu把硬件时间解释为UTC(0区的时间？)，windows把硬件时间解释为当地时间（比如，东八区），这样，ubuntu就会快整整八小时。嗯嗯,修改/etc/default/rcS里，utc=yes ---》utc=no,世界和平了

故事讲完了。

U盘为RAW格式的处理

首先，在折腾一晚上的u盘，企图装上u盘puppy（最终还是没成功）后，U盘终于旗帜鲜明地罢工，升级为让人傻眼的RAW格式，可用空间，全部空间均为零。接下来，顾不上装u盘系统了，开始想辙把u盘拯救回来。这算是今晚唯一干成的一件事。现记录如下：

1. 对于RAW格式的U盘，首先下ChipGenius查看U盘主控芯片的类型
2. 针对主控芯片的类型，当然还要是该芯片厂家的，找相应的usb量产工具
3. 利用usb量产工具进行格式化即可

回头看，较劲了几个小时的事情只能总结为三句话，这该是精炼还是悲剧啊。至于为什么会折腾那么久，首先是没有认识到量产工具这种奇妙工具的存在，另外就是，没有意识到主控芯片型号与量产工具的严格对应关系，再有就是，哪去找量产工具啊？！

ps：数码之家网站不错，ChipGenius就是他家的

检查操作系统类型

#include <windows.h>

#include <tchar.h>

#include <stdio.h>

#include <strsafe.h>

#define BUFSIZE 256

typedef void (WINAPI *PGNSI)(LPSYSTEM_INFO);

typedef BOOL (WINAPI *PGPI)(DWORD, DWORD, DWORD, DWORD, PDWORD);

BOOL GetOSDisplayString( LPTSTR pszOS)

{

   OSVERSIONINFOEX osvi;

   SYSTEM_INFO si;

   PGNSI pGNSI;

   PGPI pGPI;

   BOOL bOsVersionInfoEx;

   DWORD dwType;

   ZeroMemory(&si, sizeof(SYSTEM_INFO));

   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));

   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

   if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )

      return 1;

   // Call GetNativeSystemInfo if supported or GetSystemInfo otherwise.

   pGNSI = (PGNSI) GetProcAddress(

      GetModuleHandle(TEXT("kernel32.dll")), 

      "GetNativeSystemInfo");

   if(NULL != pGNSI)

      pGNSI(&si);

   else GetSystemInfo(&si);

   if ( VER_PLATFORM_WIN32_NT==osvi.dwPlatformId && 

        osvi.dwMajorVersion > 4 )

   {

      StringCchCopy(pszOS, BUFSIZE, TEXT("Microsoft "));

      // Test for the specific product.

      if ( osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0 )

      {

         if( osvi.wProductType == VER_NT_WORKSTATION )

             StringCchCat(pszOS, BUFSIZE, TEXT("Windows Vista "));

         else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 " ));

         pGPI = (PGPI) GetProcAddress(

            GetModuleHandle(TEXT("kernel32.dll")), 

            "GetProductInfo");

         pGPI( 6, 0, 0, 0, &dwType);

         switch( dwType )

         {

            case PRODUCT_ULTIMATE:

               StringCchCat(pszOS, BUFSIZE, TEXT("Ultimate Edition" ));

               break;

            case PRODUCT_HOME_PREMIUM:

               StringCchCat(pszOS, BUFSIZE, TEXT("Home Premium Edition" ));

               break;

            case PRODUCT_HOME_BASIC:

               StringCchCat(pszOS, BUFSIZE, TEXT("Home Basic Edition" ));

               break;

            case PRODUCT_ENTERPRISE:

               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition" ));

               break;

            case PRODUCT_BUSINESS:

               StringCchCat(pszOS, BUFSIZE, TEXT("Business Edition" ));

               break;

            case PRODUCT_STARTER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Starter Edition" ));

               break;

            case PRODUCT_CLUSTER_SERVER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Cluster Server Edition" ));

               break;

            case PRODUCT_DATACENTER_SERVER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter Edition" ));

               break;

            case PRODUCT_DATACENTER_SERVER_CORE:

               StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter Edition (core installation)" ));

               break;

            case PRODUCT_ENTERPRISE_SERVER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition" ));

               break;

            case PRODUCT_ENTERPRISE_SERVER_CORE:

               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition (core installation)" ));

               break;

            case PRODUCT_ENTERPRISE_SERVER_IA64:

               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition for Itanium-based Systems" ));

               break;

            case PRODUCT_SMALLBUSINESS_SERVER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server" ));

               break;

            case PRODUCT_SMALLBUSINESS_SERVER_PREMIUM:

               StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server Premium Edition" ));

               break;

            case PRODUCT_STANDARD_SERVER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Standard Edition" ));

               break;

            case PRODUCT_STANDARD_SERVER_CORE:

               StringCchCat(pszOS, BUFSIZE, TEXT("Standard Edition (core installation)" ));

               break;

            case PRODUCT_WEB_SERVER:

               StringCchCat(pszOS, BUFSIZE, TEXT("Web Server Edition" ));

               break;

         }

         if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )

            StringCchCat(pszOS, BUFSIZE, TEXT( ", 64-bit" ));

         else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_INTEL )

            StringCchCat(pszOS, BUFSIZE, TEXT(", 32-bit"));

      }

      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )

      {

         if( GetSystemMetrics(SM_SERVERR2) )

            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Server 2003 R2, "));

         else if ( osvi.wSuiteMask==VER_SUITE_STORAGE_SERVER )

            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Storage Server 2003"));

         else if( osvi.wProductType == VER_NT_WORKSTATION &&

                  si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)

         {

            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows XP Professional x64 Edition"));

         }

         else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2003, "));

         // Test for the server type.

         if ( osvi.wProductType != VER_NT_WORKSTATION )

         {

            if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64 )

            {

                if( osvi.wSuiteMask & VER_SUITE_DATACENTER )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition for Itanium-based Systems" ));

                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition for Itanium-based Systems" ));

            }

            else if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )

            {

                if( osvi.wSuiteMask & VER_SUITE_DATACENTER )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter x64 Edition" ));

                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise x64 Edition" ));

                else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard x64 Edition" ));

            }

            else

            {

                if ( osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Compute Cluster Edition" ));

                else if( osvi.wSuiteMask & VER_SUITE_DATACENTER )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition" ));

                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition" ));

                else if ( osvi.wSuiteMask & VER_SUITE_BLADE )

                   StringCchCat(pszOS, BUFSIZE, TEXT( "Web Edition" ));

                else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard Edition" ));

            }

         }

      }

      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )

      {

         StringCchCat(pszOS, BUFSIZE, TEXT("Windows XP "));

         if( osvi.wSuiteMask & VER_SUITE_PERSONAL )

            StringCchCat(pszOS, BUFSIZE, TEXT( "Home Edition" ));

         else StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));

      }

      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )

      {

         StringCchCat(pszOS, BUFSIZE, TEXT("Windows 2000 "));

         if ( osvi.wProductType == VER_NT_WORKSTATION )

         {

            StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));

         }

         else 

         {

            if( osvi.wSuiteMask & VER_SUITE_DATACENTER )

               StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Server" ));

            else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )

               StringCchCat(pszOS, BUFSIZE, TEXT( "Advanced Server" ));

            else StringCchCat(pszOS, BUFSIZE, TEXT( "Server" ));

         }

      }

       // Include service pack (if any) and build number.

      if( _tcslen(osvi.szCSDVersion) > 0 )

      {

          StringCchCat(pszOS, BUFSIZE, TEXT(" ") );

          StringCchCat(pszOS, BUFSIZE, osvi.szCSDVersion);

      }

      TCHAR buf[80];

      StringCchPrintf( buf, 80, TEXT(" (build %d)"), osvi.dwBuildNumber);

      StringCchCat(pszOS, BUFSIZE, buf);

      return TRUE; 

   }

   else

   {  

      printf( "This sample does not support this version of Windows.\n");

      return FALSE;

   }

}

int __cdecl _tmain()

{

    TCHAR szOS[BUFSIZE];

    if( GetOSDisplayString( szOS ) )

        _tprintf( TEXT("\n%s\n"), szOS );

}

Ubuntu Jaunty( 9.04)启用重启X windows快捷键

在Ubuntu Jaunty( 9.04)中 + + 这个快捷键组合是默认被禁用的。这个快捷的用途是重新启动 X window。本文将简单介绍如何启用这个快捷键。

首先用下面这条命令安装 "dontzap" 软件包：

sudo apt-get install dontzap

在终端中输入：

sudo dontzap -e

或者：

sudo dontzap -d

参数 "disable" 的含义是 Ctrl+Alt+Backspace 能重启 xserver 而 "enable" 意味着不能。

来源：http://blog.163.com/cczy_/blog/static/11938351320096402642692/

关于“命名空间”的一切

本文内容：

①命名空间 namespace     基本概念

②由命名空间产生的<iostream> 与 <iostream.h> 的区别

一 命名空间 namespace     基本概念及使用方法

在C++中，名称（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。 
MFC中并没有使用命名空间，但是在.NET框架、MC++和C++/CLI中，都大量使用了命名空间

与命名空间相关的概念有：

声明域（declaration region）—— 声明标识符的区域。如在函数外面声明的全局变量，它的声明域为声明所在的文件。在函数内声明的局部变量，它的声明域为声明所在的代码块（例如整个函数体或整个复合语句）。

潜在作用域（potential scope）—— 从声明点开始，到声明域的末尾的区域。因为C++采用的是先声明后使用的原则，所以在声明点之前的声明域中，标识符是不能用的。即，标识符的潜在作用域，一般会小于其声明域。

可见性（scope）—— 标识符对程序可见的范围。标识符在其潜在作用域内，并非在任何地方都是可见的。例如，局部变量可以屏蔽全局变量、嵌套层次中的内层变量可以屏蔽外层变量，从而被屏蔽的全局或外层变量在其倍屏蔽的区域内是不可见的。所以，一个标识符的作用域可能小于其潜在作用域。

命名空间

命名空间（namespace）是一种描述逻辑分组的机制，可以将按某些标准在逻辑上属于同一个集团的声明放在同一个命名空间中。

原来C++标识符的作用域分成三级：代码块（{……}，如复合语句和函数体）、类和全局。现在，在其中的类和全局之间，标准C++又添加了命名空间这一个作用域级别。

命名空间可以是全局的，也可以位于另一个命名空间之中，但是不能位于类和代码块中。所以，在命名空间中声明的名称（标识符），默认具有外部链接特性（除非它引用了常量）。

在所有命名空间之外，还存在一个全局命名空间，它对应于文件级的声明域。因此，在命名空间机制中，原来的全局变量，现在被认为位于全局命名空间中。

标准C++库（不包括标准C库）中所包含的所有内容（包括常量、变量、结构、类和函数等）都被定义在命名空间std（standard标准）中了。

2）定义命名空间
有两种形式的命名空间——有名的和无名的。

命名空间的定义格式为：（取自C++标准文档）

named-namespace-definition:

       namespace identifier { namespace-body }

unnamed-namespace-definition:

       namespace { namespace-body }

namespace-body:

       declaration-seqopt

即：（自己翻译并改写的）

有名的命名空间：

       namespace 命名空间名 {

              声明序列可选

       }

无名的命名空间：

       namespace {

              声明序列可选

       }

命名空间的成员，是在命名空间定义中的花括号内声明了的名称。可以在命名空间的定义内，定义命名空间的成员（内部定义）。也可以只在命名空间的定义内声明成员，而在命名空间的定义之外，定义命名空间的成员（外部定义）。

命名空间成员的外部定义的格式为：

命名空间名::成员名 ……

例如：

// out.h

namespace Outer {                                     // 命名空间Outer的定义

       int i;                                                     // 命名空间Outer的成员i的内部定义

       namespace Inner {                              // 子命名空间Inner的内部定义

              void f() { i++; }                                // 命名空间Inner的成员f()的内部定义，其中的i为Outer::i

              int i;

              void g() { i++; }                             // 命名空间Inner的成员g()的内部定义，其中的i为Inner::i

              void h();                                      // 命名空间Inner的成员h()的声明

       }

       void f();                                             // 命名空间Outer的成员f()的声明

       // namespace Inner2;                           // 错误，不能声明子命名空间

}

void Outer::f() {i--;}                                    // 命名空间Outer的成员f()的外部定义

void Outer::Inner::h() {i--;}                         // 命名空间Inner的成员h()的外部定义

// namespace Outer::Inner2 {/*……*/}        // 错误，不能在外部定义子命名空间

注意：

不能在命名空间的定义中声明（另一个嵌套的）子命名空间，只能在命名空间的定义中定义子命名空间。

也不能直接使用“命名空间名::成员名 ……”定义方式，为命名空间添加新成员，而必须先在命名空间的定义中添加新成员的声明。

另外，命名空间是开放的，即可以随时把新的成员名称加入到已有的命名空间之中去。方法是，多次声明和定义同一命名空间，每次添加自己的新成员和名称。例如：

namespace A {

       int i;

       void f();

} // 现在A有成员i和f()

namespace A {

       int j;

       void g();

} // 现在A有成员i、f()、j和g()

还可以用多种方法，来组合现有的命名空间，让它们为我所用。例如：

namespace My_lib {

       using namespace His_string;

       using namespace Her_vector;

       using Your_list::List;

       void my_f(String &, List &);

}

……

using namespace My_lib;

……

Vector<String> vs[5];

List<int> li[10];

my_f(vs[2], li[5]);

3）使用命名空间

作用域解析运算符（::）

对命名空间中成员的引用，需要使用命名空间的作用域解析运算符::。例如：

// out1.cpp

#include "out.h"

#include <iostream>

int main ( ) {

       Outer::i = 0;

       Outer::f(); // Outer::i = -1;

       Outer::Inner::f(); // Outer::i = 0;

       Outer::Inner::i = 0;

       Outer::Inner::g(); // Inner::i = 1;

       Outer::Inner::h(); // Inner::i = 0;

       std::cout << "Hello, World!" << std::endl;

       std::cout << "Outer::i = " << Outer::i << ", Inner::i = " << Outer::Inner::i << std::endl;

}

using指令（using namespace）

为了省去每次调用Inner成员和标准库的函数和对象时，都要添加Outer::Inner::和sta::的麻烦，可以使用标准C++的using编译指令来简化对命名空间中的名称的使用。格式为：

using namespace 命名空间名[::命名空间名……];

在这条语句之后，就可以直接使用该命名空间中的标识符，而不必写前面的命名空间定位部分。因为using指令，使所指定的整个命名空间中的所有成员都直接可用。例如：

// out2.cpp

#include "out.h"

#include <iostream>

// using namespace Outer; // 编译错误，因为变量i和函数f()有名称冲突

using namespace Outer::Inner;

using namespace std;

int main ( ) {

       Outer::i = 0;

       Outer::f();                // Outer::i = -1;

       f();                         // Inner::f()，Outer::i = 0;

       i = 0;                       // Inner::i

       g();                         // Inner::g()，Inner::i = 1;

       h();                         // Inner::h()，Inner::i = 0;

       cout << "Hello, World!" << endl;

       cout << "Outer::i = " << Outer::i << ", Inner::i = " << i << endl;

}

又例如：（.NET框架）

using namespace System::Drawing::Imaging;

using namespace System::Window::Forms::Design::Behavior;

using声明（using）

除了可以使用using编译指令（组合关键字using namespace）外，还可以使用using声明来简化对命名空间中的名称的使用。格式为：

using 命名空间名::[命名空间名::……]成员名;

注意，关键字using后面并没有跟关键字namespace，而且最后必须为命名空间的成员名（而在using编译指令的最后，必须为命名空间名）。

与using指令不同的是，using声明只是把命名空间的特定成员的名称，添加该声明所在的区域中，使得该成员可以不需要采用，（多级）命名空间的作用域解析运算符来定位，而直接被使用。但是该命名空间的其他成员，仍然需要作用域解析运算符来定位。例如：

// out3.cpp

#include "out.h"

#include <iostream>

using namespace Outer;                                              // 这是 using命令注意，此处无::Inner

using namespace std;

// using Inner::f;                                                            // 编译错误，因为函数f()有名称冲突

using Inner::g;                                                      // using 声明此处省去Outer::，是因为Outer已经被前面的using指令作用过了

using Inner::h;

int main ( ) {

       i = 0;                                                          // Outer::i

       f();                                                              // Outer::f()，Outer::i = -1;

       Inner::f();                                                    // Outer::i = 0;

       Inner::i = 0;

       g();                                                            // Inner::g()，Inner::i = 1;

       h();                                                            // Inner::h()，Inner::i = 0;

       cout << "Hello, World!" << endl;

       cout << "Outer::i = " << i << ", Inner::i = " << Inner::i << endl;

}

using指令与using声明的比较：

可见，using编译指令和using声明，都可以简化对命名空间中名称的访问。

using指令使用后，可以一劳永逸，对整个命名空间的所有成员都有效，非常方便。而using声明，则必须对命名空间的不同成员名称，一个一个地去声明，非常麻烦。

但是，一般来说，使用using声明会更安全。因为，using声明只导入指定的名称，如果该名称与局部名称发生冲突，编译器会报错。而using指令导入整个命名空间中的所有成员的名称，包括那些可能根本用不到的名称，如果其中有名称与局部名称发生冲突，则编译器并不会发出任何警告信息，而只是用局部名去自动覆盖命名空间中的同名成员。特别是命名空间的开放性，使得一个命名空间的成员，可能分散在多个地方，程程序员难以准确知道，别人到底为该命名空间添加了哪些名称。虽然使用命名空间的方法，有多种可供选择。但是不能贪图方便，一味使用using 指令，这样就完全背离了设计命名空间的初衷，也失去了命名空间应该具有的防止名称冲突的功能。

一般情况下，对偶尔使用的命名空间成员，应该使用命名空间的作用域解析运算符来直接给名称定位。而对一个大命名空间中的经常要使用的少数几个成员，提倡使用using声明，而不应该使用using编译指令。只有需要反复使用同一个命名空间的许多数成员时，使用using编译指令，才被认为是可取的。

例如，如果一个程序（如上面的outi.cpp）只使用一两次cout，而且也不使用std命名空间中的其他成员，则可以使用命名空间的作用域解析运算符来直接定位。如：

#include <iostream>

……

std::cout << "Hello, World!" << std::endl;

std::cout << "Outer::i = " << Outer::i << ", Inner::i = " << Outer::Inner::i << std::endl;

又例如，如果一个程序要反复使用std命名空间中的cin、cout和cerr（如上面的outi.cpp），而不怎么使用其他std命名空间中的其他成员，则应该使用using 声明而不是using指令。如：

#include <iostream>

……

using std::cout;

cout << "Hello, World!" << endl;

cout << "Outer::i = " << Outer::i << ", Inner::i = " << Outer::Inner::i << endl;

4）命名空间的名称

命名空间别名

标准C++引入命名空间，主要是为了避免成员的名称冲突。若果用户都给自己的命名空间取简短的名称，那么这些（往往同是全局级的）命名空间本身，也可能发生名称冲突。如果为了避免冲突，而为命名空间取很长的名称，则使用起来就会不方便。这是一个典型的两难问题。

标准C++为此提供了一种解决方案——命名空间别名，格式为：

namespace 别名 = 命名空间名;

例如：（AT&T美国电话电报公司）

namespace American_Telephone_and_Telegraph { // 命名空间名太长

       class String {

              String(const char*);

              // ……

       }

}

American_Telephone_and_Telegraph::String s1 // 使用不方便

= new American_Telephone_and_Telegraph::String("Grieg");

namespace ATT = American_Telephone_and_Telegraph; // 定义别名

ATT::String s2 = new ATT::String("Bush"); // 使用方便

ATT::String s3 = new ATT::String("Nielsen");

<!--[if !supportLists]-->l     <!--[endif]-->无名命名空间

标准C++引入命名空间，除了可以避免成员的名称发生冲突之外，还可以使代码保持局部性，从而保护代码不被他人非法使用。如果你的目的主要是后者，而且又为替命名空间取一个好听、有意义、且与别人的命名空间不重名的名称而烦恼的话，标准C++还允许你定义一个无名命名空间：可以在当前编译单元中（无名命名空间之外），直接使用无名命名空间中的成员名称，但是在当前编译单元之外，它又是不可见的。

无名命名空间的定义格式为：

namespace {

       声明序列可选

}

实际上，上面的定义等价于：（标准C++中有一个隐含的使用指令）

namespace $$$ {

       声明序列可选

}

using namespace $$$;

例如：

namespace {

       int i;

       void f() {/*……*/}

}

int main() {

       i = 0;                                                    // 可直接使用无名命名空间中的成员i

       f();                                                       // 可直接使用无名命名空间中的成员f()

}

参考：http://www.91linux.com/html/article/program/cpp/20080220/9737_3.html

二 <iostream>和<iostream.h> 的区别

<iostream>和<iostream.h>是不一样，前者没有后缀，实际上，在你的编译器include文件夹里面可以看到，二者是两个文件，打开文件就会发现，里面的代码是不一样的。 

后缀为.h的头文件c++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h后缀的头文件里，c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。 

因此，当使用<iostream.h>时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现；当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。

所谓namespace，是指标识符的各种可见范围。

C＋＋标准程序库中的所有标识符都被定义于一个名为std的namespace中。

由于namespace的概念，使用C＋＋标准程序库的任何标识符时，可以有三种选择：

1、直接指定标识符。例如std::ostream而不是ostream。完整语句如下：

std::cout << std::hex << 3.4 << std::endl;

2、使用using关键字。

using std::cout;
using std::endl;

以上程序可以写成

cout << std::hex << 3.4 << endl;

3、最方便的就是使用using namespace std;

例如：

#include <iostream>
#include <sstream>
#include <string>
using namespace std;
这样命名空间std内定义的所有标识符都有效（曝光）。就好像它们被声明为全局变量一样。那么以上语句可以如下写:

cout << hex << 3.4 << endl;

因为标准库非常的庞大，所程序员在选择的类的名称或函数名时就很有可能和标准库中的某个名字相同。所以为了避免这种情况所造成的名字冲突，就把标准库中的一切都被放在名字空间std中。但这又会带来了一个新问题。无数原有的C++代码都依赖于使用了多年的伪标准库中的功能，他们都是在全局空间下的。  

         所以就有了<iostream.h>和<iostream>等等这样的头文件，一个是为了兼容以前的C++代码，一个是为了支持新的标准。

命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加".h"