全局对象的析构顺序

开宗明义：全局对象的析构顺序是不确定的，最好不要在程序逻辑中依赖这个顺序（免得出现移植问题）。

问题关注的焦点主要集中在："cout是否会最先构造、最后析构"？

　★关于老式编译器（03年之前推出）
　　由于老式编译器在标准发布之前推出，因此对标准的实现不够好。
　　老式编译器的典型代表就是VC++ 6.0。其实已经有很多人碰到了"VC6的cout提前析构"的问题。另外，如果你手头上正好有VC6，可以试试附在本文末尾的示例1的代码，看是否能够正常打印，就知道了。
　　
　　★关于新式编译器（03年之后推出）
　 　那么新式编译器是否就完美地支持C++ 03标准呢？所以今天特地试验了手头能找到的几个C++编译器。看看它们是否能够保证cout最先构造、最后析构。另外，为了给这些新式编 译器增加点挑战，我把上述的示例1代码稍微修改了一下，成为示例2代码（说实话，这么写代码确实有点夸张），也附在本文末尾。
　　手头的几种编译器测试下来，结果如下：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
　　操作系统　编译器版本　　　　　　示例1　　示例2
　　Win2000　　VC 7.1　　　　　　　OK　　　OK
　　RHEL3　　　GCC 3.2.3　　　　　　OK　　　OK
　　Win2000　　GCC 3.4.2(MingW)　　OK　　　启动时崩溃
　　Win2003　　GCC 3.4.4(Cygwin)　　OK　　　启动时崩溃
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
　　对于示例2代码造成的崩溃，经过简单排查，基本可以推断是cout滞后构造导致（也就是用到cout时，它还没生出来）。而且GCC 3.4.2版本是2004年出品的，应该不算太老啊（至少03标准已经发布一年了）。从上面的结果看，Linux上版本较老的GCC反而没有问题。所以我猜测或许GCC在Windows上的移植版本有这个缺陷（仅仅是猜测啊）。

　★总结
　　根据上述的情况，建议：如果你的代码有全局对象，并且你的代码可能会跨编译器，那就避免在全局对象的构造函数和析构函数中使用标准流类库的那八个玩意儿（包括cout、cerr、clog等）。
　　毕竟这八个全局对象，都有对应的标准C替代品，并不是不可替代的嘛。大伙儿犯不着冒险嘛。如果你确实舍不得流式操作符（<<和>>）或者确实看不惯printf的变参，你可以用字符串流先格式化好，再用标准C的函数输出嘛（也就多一两行代码而已嘛）。

// ========示例1代码========
#include <iostream>
using namespace std;

class CFoo
{
public:
CFoo()
{
cout << "CFoo" << endl;
}

~CFoo()
{
cout << "~CFoo" << endl;
}
};

CFoo g_foo;

int main()
{
return 0;
}

// ========示例2代码========
class CFoo
{
public:
CFoo();
~CFoo();
};

CFoo g_foo;

#include <cstdio>
#include <iostream>
using namespace std;

CFoo::CFoo()
{
puts("puts CFoo");
cout << "cout CFoo" << endl;
}

CFoo::~CFoo()
{
cout << "cout ~CFoo" << endl;
puts("puts ~CFoo");
}

int main()
{
return 0;
}

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"

关闭qq脚本


On Error Resume Next
'vbs代码开始----------------------------------------------
sub Close_Process(ProcessName)
On Error Resume Next
for each ps in getobject("winmgmts:\\.\root\cimv2:win32_process").instances_ '循环进程
if Ucase(ps.name)=Ucase(ProcessName) then
ps.terminate
end if
next
end sub

Close_Process("qq.exe")
Close_Process("TXplatform.exe")


Windows XP 内置管理员帐户无法执行任务计划

在使用内置的管理员帐户登录系统并且是空白密码的情况下，在“任务计划”中添加任务时，出现如下提示：
已创建新任务，但可能不能运行，因为无法设置帐户信息.
指定的错误是:
0×80070005: 拒绝访问。
请试着使用“任务”的浏览按钮来定位应用程序.


找到以下3个解决方法，可任选一个：
1.先为这个内置的管理员帐户创建密码，然后到“任务计划”中设置任务的密码即可。
2.如果不想这么麻烦设置密码，可以使用系统提供的 at 命令。
将要执行的任务编辑成一个 bat 批处理文件，添加到系统的启动项中。
注意使用批处理系统会为每一行命令创建一个任务，所以为了避免产生过期的任务计划，可以在批处理文件的开关添加一行：at /delete /yes 用于删除登录前的所有任务计划。
例如：

at /delete /yes
at 23:00 C:\WINDOWS\system32\shutdown.exe -s
at 00:00 C:\WINDOWS\system32\shutdown.exe -s
at 01:00 C:\WINDOWS\system32\shutdown.exe -s

3.如果还要更省事点，可以用如下方法：
观察一下使用 at 命令添加的任务计划，会发现这些任务的“运行方式”都是 NT AUTHORITY\SYSTEM。所以只要将手动创建的任务计划的的“运行方式”设置成 NT AUTHORITY\SYSTEM 这个系统用户即可。
不需要密码。
“仅在登录后运行(L)”这个选项，选不选都可以。选的话，不会提示输入密码；不选的话，提示输入密码，留空即可。

备注：
和任务计划相关的系统服务：
Task Scheduler
Event Log
这两个后台服务必须已启用，而且启动方式应该都是“自动”。“手动”模式的话，系统无法启动服务本身！

如何不用输入用户名密码登陆XP?

在运行中输入control userpasswords2
在打开“用户帐号”中把 “要使用本机用户必须输入用户名和密码”前的钩打掉。按“确定”，提示输入默认登陆的帐号密码。

qq2009脚本自动登陆 v2

更新：1.添加测试网络连接部分
2.使用select case 语句

Dim WshShell, QQPath, QQselect
QQPath="""C:\Program Files\Tencent\QQ\Bin\QQ.exe"""
Set WshShell=WScript.CreateObject("WScript.Shell")

If WeekDay(date)=7 Then WScript.Quit
IF WeekDay(date)=1 Then WScript.Quit

''''测试网络连接
Do While 1
Url="ping www.google.com -n 1"
Return=WshShell.Run( "cmd /c"&Url,0,true)
If Return=0 then Exit Do '测试成功,不成功则继续等待
Wscript.Sleep 100
Loop

Set oQQ = WshShell.Exec(QQPath)

Do While 1
If WshShell.AppActivate(oQQ.ProcessID)=True Then '''激活qq窗口
'''移动光标到帐号密码输入框
Wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 200

Select Case WeekDay(date)
case 2
WshShell.SendKeys"qq1"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"password1"
WScript.Sleep 500

case 3
WshShell.SendKeys"qq2"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
Wshshell.sendkeys"password2"
WScript.Sleep 500

case 4
WshShell.SendKeys"qq3"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
wshshell.sendkeys"password3"
WScript.Sleep 500

case 5
WshShell.SendKeys"qq4"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"password4"
WScript.Sleep 500

case 6
WshShell.SendKeys"qq5"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"password5"
WScript.Sleep 500

End Select
'''输入帐号密码完毕
WshShell.SendKeys"{ENTER}"

Exit Do
END IF
Wscript.Sleep 100
Loop


qq2009脚本自动登陆


Dim WshShell, QQPath, QQselect
QQPath="""C:\Program Files\Tencent\QQ\Bin\QQ.exe"""
Set WshShell=WScript.CreateObject("WScript.Shell")

If WeekDay(date)=7 Then WScript.Quit
IF WeekDay(date)=1 Then WScript.Quit

Set oQQ = WshShell.Exec(QQPath)

Do While 1
If WshShell.AppActivate(oQQ.ProcessID)=True Then

If WeekDay(date)=2 Then
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
WshShell.SendKeys"qq1"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"password1"
WScript.Sleep 500
WshShell.SendKeys"{ENTER}"
ELSE
If WeekDay(date)=3 Then
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
WshShell.SendKeys"qq2"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"pw2"
WScript.Sleep 500
WshShell.SendKeys"{ENTER}"

ELSE
If WeekDay(date)=4 Then
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
WshShell.SendKeys"qq3"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
wshshell.sendkeys"pw3"
WScript.Sleep 500
WshShell.SendKeys"{ENTER}"

ELSE
If WeekDay(date)=5 Then
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
WshShell.SendKeys"qq4"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"pw4"
WScript.Sleep 500
WshShell.SendKeys"{ENTER}"
ELSE
If WeekDay(date)=6 Then
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 100
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
WshShell.SendKeys"qq5"
WScript.Sleep 500
wshshell.sendkeys"{TAB}"
WScript.Sleep 200
wshshell.sendkeys"pw5"
WScript.Sleep 500
WshShell.SendKeys"{ENTER}"


END IF
END IF
END IF
END IF
END IF
Exit Do
END IF
Wscript.Sleep 100
Loop


ie右键添加“收藏到qq书签”

安装：

REGEDIT4

[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\MenuExt]

[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\MenuExt\收藏到QQ书签]

@="http://shuqian.qq.com/favit.html"

卸载：

REGEDIT4

[-HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\MenuExt\收藏到QQ书签]

十进制&十六进制ip地址 囧rz

常见的ip地址为点分十进制。以www.taobao.com为例，ping 下可以知道ip地址为61.164.54.30 。

十六进制地址转换;
先将“61.164.54.30”转换为十六进制 .
不会算的利用计算器科学模式换算。
61=3d
164=a4
54=36
30=1e

即为“3d.a4.36.1e”，然后去掉小数点后，变为“3da4361e”。此时，ping 0x3da4361e，可以看到这串十六进制数字被解释成61.164.54.30.


十进制地址转换：


更进一步，将得到的十六进制0x3da4361e 转换成1034171934。同样，ping 1034171934，可以看到该十进制也被解释成ip地址。

修复6700.cn篡改主页

www.3929.cn，www.sl400.cn和www.6700.cn篡改主页还在为ie首页被www.3929.cn、www.sl400.cn和www.6700.cn郁闷？咱们手动来干掉它们！这段时间修改用户首页的木马开始猖獗了，其实清理起来比较容易的，主要是看系统诊断报告。作为标准的360安全卫士诊断报告，需要注意的是：o40（dll注入）和o41（驱动服务）。

如果你的ie首页被篡改，你可以导出360安全卫士诊断报告，然后查看o41，一般没问题的报告应该像卡巴斯基驱动这样：
o41 - klif - spuper-ptor - c:\windows\system32\drivers\klif.sys - (running) - spuper-ptor - kaspersky lab - 9256da35cee573515d346b4f3598b72e

一般情况下，木马的驱动服务红色部分是缺失的。下面这样的应该就是很可疑的：（这是修改主页的恶意程序）
o41 - mirty - mirty - c:\windows\system32\drivers\mirty.sys - (running) - - -

www.3929.cn、www.sl400.cn和www.6700.cn都是通过驱动来修改首页的，驱动文件为5位随即英随机英文字母组成，例如mirty.sys。


那么恢复我们的ie主页吧：
1.安装unlocker之后在需要删除的文件上点右键，选择使用unlocker解锁，然后弹出对话框种选择全部解锁删除，删除之后确定文件已经不存在！
2.重启电脑使用360安全卫士修复ie。

文件夹加密超级大师

强大的文件和文件夹加密软件，还具有彻底隐藏磁盘以及禁止使用或只读使用USB存储设备、数据粉碎删除等功能。

软件特色功能：

1、对文件夹具有五种加密方法：除了有加密强度极高、加解密快速的闪电和隐藏加密；还有用国际上成熟领先的加密算法，将文件夹内所有文件加密成加密文件的全面加密；把文件夹打包加密成加密文件的金钻加密；把文件夹加密成EXE文件的移动加密；这五种加密方式可以满足各种不同的需要。

2、加密文件和文件夹的临时解密；加密文件和文件夹解密时输入正确密码选择打开，就处于临时解密状态，使用完毕后文件及文件夹自动恢复到加密状态，不需要再次加密。

3、磁盘彻底隐藏；磁盘彻底隐藏后，在任何环境下无法找到。

4、禁止使用或只读使用USB存储设备；

5、不仅可以加密文件夹，还可以加密文件；加密文件也是采用加密算法加密，确保你的绝密文件的保密性。

6、文件和文件夹的粉碎删除；粉碎删除后的文件和文件夹是无法通过数据恢复软件恢复的。

7、还具有系统安全设置、优化系统、系统垃圾清理等辅助功能。

怎么样？一套完美的数据加密保护方案是不是呈现在你的眼前，那你还等什么呢？

下载地址

点点点

张·三 alt+183
张三° alt+176

Blogger标签云

首先确认你添加了标签小工具，然后可以按以下步骤更改模板html

1.先找到 ]]>。将以下代码,贴在 ]]> 之前.

/* Label Cloud Styles

----------------------------------------------- */

#labelCloud {text-align:center;font-family:arial,sans-serif;}

#labelCloud .label-cloud li{display:inline;background-image:none
!important;padding:0 5px;margin:0;vertical-align:baseline !important;border:0
!important;}

#labelCloud ul{list-style-type:none;margin:0 auto;padding:0;}

#labelCloud a img{border:0;display:inline;margin:0 0 0 3px;padding:0}

#labelCloud a{text-decoration:none}

#labelCloud a:hover{text-decoration:underline}

#labelCloud li a{}

#labelCloud .label-cloud {}

#labelCloud .label-count {padding-left:0.2em;font-size:9px;color:#000}

#labelCloud .label-cloud li:before{content:"" !important}



2.找到 </head>,在 </head> 之前, 贴以下代码.

<script type='text/javascript'>
// Label Cloud User Variables
var lcBlogURL = 'http://YOURBLOG.blogspot.com';
var cloudMin = 1;
var maxFontSize = 20;
var maxColor = [0,0,255];
var minFontSize = 10;
var minColor = [0,0,0];
var lcShowCount = false;
</script>

如果有需要的话，可适当更改这段代码来调整字体大小和颜色。

3. 找到這一列代码


<b:widget id='Label1' locked='false'
title='Labels' type='Label'/>



用下面的代码替换

<b:widget id='Label1' locked='false' title='Label Cloud' type='Label'>
<b:includable id='main'>
<b:if cond='data:title'>
<h2><data:title/></h2>
</b:if>
<div class='widget-content'>
<div id='labelCloud'/>
<script type='text/javascript'>
// Don't change anything past this point -----------------
// Cloud function s() ripped from del.icio.us
function s(a,b,i,x){
if(a>b){
var m=(a-b)/Math.log(x),v=a-Math.floor(Math.log(i)*m)
}
else{
var m=(b-a)/Math.log(x),v=Math.floor(Math.log(i)*m+a)
}
return v
}
var c=[];
var labelCount = new Array();
var ts = new Object;
<b:loop values='data:labels' var='label'>
var theName = "<data:label.name/>";
ts[theName] = <data:label.count/>;
</b:loop>
for (t in ts){
if (!labelCount[ts[t]]){
labelCount[ts[t]] = new Array(ts[t])
}
}
var ta=cloudMin-1;
tz = labelCount.length - cloudMin;
lc2 = document.getElementById('labelCloud');
ul = document.createElement('ul');
ul.className = 'label-cloud';
for(var t in ts){
if(ts[t] < cloudMin){
continue;
}
for (var i=0;3 > i;i++) {
c[i]=s(minColor[i],maxColor[i],ts[t]-ta,tz)
}
var fs = s(minFontSize,maxFontSize,ts[t]-ta,tz);
li = document.createElement('li');
li.style.fontSize = fs+'px';
li.style.lineHeight = '1';
a = document.createElement('a');
a.title = ts[t]+' Posts in '+t;
a.style.color = 'rgb('+c[0]+','+c[1]+','+c[2]+')';
a.href = '/search/label/'+encodeURIComponent(t);
if (lcShowCount){
span = document.createElement('span');
span.innerHTML = '('+ts[t]+') ';
span.className = 'label-count';
a.appendChild(document.createTextNode(t));
li.appendChild(a);
li.appendChild(span);
}
else {
a.appendChild(document.createTextNode(t));
li.appendChild(a);
}
ul.appendChild(li);
abnk = document.createTextNode(' ');
ul.appendChild(abnk);
}
lc2.appendChild(ul);
</script>
<noscript>
<ul>
<b:loop values='data:labels' var='label'>
<li>
<b:if cond='data:blog.url == data:label.url'>
<data:label.name/>
<b:else/>
<a expr:href='data:label.url'><data:label.name/></a>
</b:if>
(<data:label.count/>)
</li>
</b:loop>
</ul>
</noscript>
<b:include name='quickedit'/>
</div>
</b:includable>
</b:widget>



然后就大功告成啦。

在blogger文章中显示代码

如果你尝试过在blogger中发表带有<或者>符号的html代码，你会郁闷地发现代码是显示不出来的。你需要在html模式下,将所有的<替换成＆lt;所有>替换成＆gt;(注意&是半角符号)。用这种方法不仅可以在 Blogger里正常输出文件，而且COPY后不用再去替换全角。
为了美观，可以在CSS样式表中加入下面css代码

CODE {
display: block; /* fixes a strange ie margin bug */
font-family: Courier New;
font-size: 8pt;
overflow:auto;
background: #f0f0f0 url(http://kofreestyler.googlepages.com/Code_BG.gif) left top repeat-y;
border: 1px solid #ccc;
padding: 0px 10px 10px 21px;
max-height:200px;
line-height: 1.2em;
}

在编写帖子时，在代码两边加上code,可以达到跟上面一样的效果。

注意：代码部分必须用“＆lt;”代替“<”，用 “＆gt;”代替“>”，否则帖子在发布之后还是无法显示出HTML代码的，切记。如果“<”和“>”的数量不多，手动输入即可；如果是一大段的代码，建议使用Dreamweaver或其他的网页编辑工具进行转换。

根据当前目录名合并新的文本

当前目录下有一些txt，要将这些txt合并为一个文本，并将文件名取为当前目录名。

脚本：

@echo off

for /f "delims=" %%i in ("%cd%") do (

if exist %%~ni.txt del %%~ni.txt

:* 有问题.

for %%a in (*.txt) do type "%%a">>"%%~ni.txt"

)

上面版本有一个问题。例如，如果当前目录名为5，本来有1.txt,2.txt，3.txt三个文本，所得到的5.txt将是原本3个文本内容的两份长度。猜想是由于上述“有问题”的那个语句，是按txt文件名顺序执行的。因为5.txt排序在原本三个文本之后，执行完原本三个txt 写入命令，当前目录下已然生成有5.txt，“有问题”语句将5.txt也写入新的5.txt，照成内容的重复。

修订脚本：

@echo off

for /f "delims=" %%i in ("%cd%") do (

if exist %%~ni.txt del %%~ni.txt

:*修改后的语句

for /f "delims=" %%a in ('dir /b *.txt') do type "%%a">>"%%~ni.txt"

)

根据当前目录名批量改文件名

如何根据目录名批量更改文件名(对该目录下所有子目录有效)?
如文件夹名为：东邪西毒OST
如何将此文件夹下的所有mp3文件改名为

东邪西毒OST-001.mp3
东邪西毒OST-002.mp3
东邪西毒OST-003.mp3


脚本：

@echo off & SetLocal EnableDelayedExpansion

:* 列出当前目录下包括子目录下所有要求文件
for /f "delims=" %%a in ('dir /s/b/a-d *.jpg *.bmp') do (

:* %%~dpa后的.很犀利,不加.后面的%%~nb将为空
for /f "delims=" %%b in ("%%~dpa.") do (

:* 监测是否换子目录，决定是否重新计数
if not "!_batch!"=="_%%~nb" set _batch=_%%~nb&set num=0&echo....

set /a num+=1
set nums=00!num!
set nums=!nums:~-3!
ren "%%~a" "%%~nb-!nums!%%~xa"
)
)


命令行中输入中文

很莫名其妙地，系统在cmd中居然无法输入中文，ctrl+space切换输入法无效。

解决方法：

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Console]
"LoadConIme"=dword:00000001


通过CMOS开机的几种方法

第一招：定时开机　　现在大多数人的电脑均可支持定时开机功能。比如笔者每天是8:30上班，设定为每天8:30定时开机之后，只要上班的时间一到就会自动开启电脑。呵呵，这样是不是很方便呀？
　　实现条件：首先确认你所使用的电源为ATX电源，然后再查看CMOS设置当中是否有“Resume by Alarm”、“RTC Alarm Resume”或类似的选项（不同的主板，此选项与设置值可能有所不同）。
　　实现步骤：开机自检后按“Del”键进入CMOS设置。在主菜单中，进入“Power Management Setup”（电源管理设置）菜单，将“Resume by Alarm”选项设置成“Enabled”，如图1所示。这时下面的“Date（of Month） Alarm”子选项和“Time（hh:mm:ss） Alarm”子选项将激活成高亮显示，也就是可设置的状态。接着用方向键选择到“Date（of Month） Alarm”子选项，此选项一般不用设置，而直接采用默认值“0”，表示每天都适用。如果你不想系统在每天都定时开机，也可以自定义在哪一天启动。再用方向键移动到“Time（hh:mm:ss） Alarm”子选项，通过“Page UP”键或“Page Down”键设置系统在什么时间启动，格式为“时:分:秒”，此时间是以系统时钟为准。最后按“ESC”键退出此菜单，再选择“Save & Quit Setup”菜单（或按“F10”键）并按回车键保存并退出CMOS设置即可。下次关机时只要不断开电源，即可定时开机了。

第二招：密码开机　　密码开机跟在CMOS设置当中设定“Set Supervisor Password（设置超级用户密码）”或“Set User Password（设置用户密码）”是不一样的。前者是ATX电源激活的状态下，不需要按主机前面板的电源开关，就可以直接通过密码开机；后者是必须按主机前面板的电源开关，然后输入“Set Supervisor Password”或“Set User Password”密码进行开机。
　　实现条件：要实现热键开机前，必须检查所用的ATX电源的5V待命电流不小于300mA，然后再查看CMOS设置当中是否有“POWER ON Function”、“Keyboard/Mouse Power On”或类似的选项（不同的主板，此选项与设置值可能有所不同）。
　　实现步骤：开机自检后按“Del”键进入CMOS设置。在主菜单中，进入“Integrated Peripherals”菜单，将“POWER ON Function”选项设置成 “Password”（如图2所示）。这时下面的“KB Power ON Password”子选项将激活成高亮显示，也就是可设置的状态。用方向键移动到“KB Power ON Password”子选项，并按下回车键。这时输入密码即可，此热键仅限字母键区的26个英文字母和0-9阿拉伯数字，以及数字键区的0-9阿拉伯数字。最后按“ESC”键退出此菜单，再选择“Save & Quit Setup”菜单（或按“F10”键）并按回车键保存并退出CMOS设置即可。下次关机时只要不断开电源，输入之前设置的密码就可以开机了。

第三招：热键开机　　热键开机与密码开机有所不同，热键开机可设定为PS/2键盘的任意键开机或组合键开机。
　　实现条件：与“密码开机”小节相同。
　　实现步骤：开机自检后按“Del”键进入CMOS设置。在主菜单中，进入“Integrated Peripherals”菜单，将“POWER ON Function”选项设置成“Hot KEY”（热键）或“Any KEY”（任意键），如图3所示。如果选择“Hot KEY”，这时下面的“Hot Key Power On”子选项将激活成高亮显示，用方向键移动到“Hot Key Power On”子选项，将其设置成“Ctrl-F1”～“Ctrl-F12”其中一项；如果选择“Any KEY”，则可以通过任意键来激活电源。最后按“ESC”键退出此菜单，再选择“Save & Quit Setup”菜单（或按“F10”键）并按回车键保存并退出CMOS设置即可。下次关机时只要不断开电源，输入之前设置热键就可以开机了。

第四招：鼠标开机　　很少人听说通过PS/2鼠标也可以开机的吧？其实实现起来很容易，步骤与热键开机是差不多的。
　　实现条件：与“密码开机”小节相同。
　　实现步骤：开机自检后按“Del”键进入CMOS设置。在主菜单中，进入“Integrated Peripherals”菜单，将“POWER ON Function”选项设置成“Mouse Left”（鼠标左键）或“Mouse Right”（鼠标右键），如图4所示。最后按“ESC”键退出此菜单，再选择“Save & Quit Setup”菜单（或按“F10”键）并按回车键保存并退出CMOS设置即可。下次关机时只要不断开电源，即可通过鼠标左键或鼠标右键开机了。
　　小提示：有些主板上还可能提供有启用热键开机和鼠标开机的跳线，如果有的话，必须设置为启用状态。

第五招：通电自动开机　　这次开机方式算是另类的，只要接通主机电源，电脑就自动开机了，而不用按主机前面板的电源开关。
　　实现条件：首先确认你所使用的电源为ATX电源，然后再查看CMOS设置当中是否有“Soft-Off by PWR-BTTN”、“System After AC Back”或类似的选项（不同的主板，此选项与设置值可能有所不同）。
　　实现步骤：开机自检后按“Del”键进入CMOS设置。在主菜单中，进入“Power Management Setup”菜单，将“Soft-Off by PWR-BTTN”选项设置成“Instant-On”（笔者这块主板无法设置成此项目），如图5所示。最后按“ESC”键退出此菜单，再选择“Save & Quit Setup”菜单（或按“F10”键）并按回车键保存并退出CMOS设置即可。以后只要连接电源（如果机箱后方的电源供应器有开关的话，也可以通过此开关进行开机）即可开机。而一般在正常情形下，电源供应器应在激活前方电源开关才可开机。

第六招：USB键盘开机 　　最后一种开机方式就是通过USB键盘唤醒开机。没有使用USB键盘的用户可不要眼红了喔^_^
　　实现条件：首先确认你所使用的ATX电源的5V待命电流不小于800mA，然后查看CMOS设置当中是否有“USB Controller”和“USB KB Wake-Up From S3”或类似的功能选项（不同的主板，此选项与设置值可能有所不同），最后要确认已连接USB设备。
　　实现步骤：开机自检后按“Del”键进入CMOS设置。在主菜单中，进入“Integrated Peripherals”菜单，将“USB Controller”选项设置成“Enabled”，如图9所示。如果你是使用USB键盘，还要将下面的“USB Keyboard Support”选项设置成“Enabled”。
　　接着按“ESC”键退回主菜单，进入“Power Management Setup”菜单，将“ACPI Suspend Type”（ACPI待命模式）选项设置成“S3（STR）”或“S1&S3”，如图10所示。这时下面的“USB KB Wake-Up From S3”选项将激活成高亮显示，也就是可设置的状态。将“USB KB Wake-Up From S3”选项设置成“Enabled”。最后按“ESC”键退出此菜单，再选择“Save & Quit Setup”菜单（或按“F10”键）并按回车键保存并退出CMOS设置即可。以后电脑只要在睡眠状态中，通过USB键盘的任意键就可以唤醒这台电脑。
　　小提示：有些主板上还可能提供有启用USB设备开机的跳线，如果有的话，必须设置为启用状态。

文件夹右键进入命令行

经常进行入侵测试的朋友都知道，要完成整个入侵测试，要使用到各种各样的黑客工具，而这些黑客工具中有很多是只能在CMD窗口执行的。默认情况下打开的CMD窗口，都会在系统当前账户的目录下，如果用户的黑客软件在其他的盘符或目录中，就必须使用CD命令一层一层地进入。下面就来告诉大家一个在CMD窗口下，快速进入任意目录的方法。点击“开始”菜单中的“运行”命令，执行“REGEDIT”命令打开注册表编辑器。依次展开HKEY_CLASSES_ROOT\Folder\shell，接着在该项目下新建一项，并命名为“CommandPrompt”，然后将右侧窗口中的“默认”值改为“快速进入CMD窗口”（或者其他个人喜欢的语句）；再在刚刚创建的“CommandPrompt”项目下再创建一个项目，取名为“command”，接着将右侧窗口中的“默认”值改为“cmd.exe /k cd %1”（如果是WIN 9X用户的话，则要将cmd.exe替换为command.com才行），最后关闭退出。　　设置完相关的注册表信息后，无须重新启动系统，就可以在任意的盘符或目录上点击鼠标右键中的“快速进入CMD窗口”命令。不管当前目录有多深，在弹出的CMD窗口中显示出来的都会是当前这个目录。