方法一：

string WideToMutilByte(const wstring& _src)
{
int nBufSize = WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, NULL, 0, 0, FALSE);

char *szBuf = new char[nBufSize];

WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, szBuf, nBufSize, 0, FALSE);

string strRet(szBuf);

delete []szBuf;
szBuf = NULL;

return strRet;
}

wstring MutilByteToWide(const string& _src)
{
//计算字符串 string 转成 wchar_t 之后占用的内存字节数
int nBufSize = MultiByteToWideChar(GetACP(),0,_src.c_str(),-1,NULL,0);

//为 wsbuf 分配内存 BufSize 个字节
wchar_t *wsBuf = new wchar_t[nBufSize];

//转化为 unicode 的 WideString
MultiByteToWideChar(GetACP(),0,_src.c_str(),-1,wsBuf,nBufSize);

wstring wstrRet(wsBuf);

delete []wsBuf;
wsBuf = NULL;

return wstrRet;
}

转载：csdn

这篇文章里，我将给出几种C++ std::string和std::wstring相互转换的转换方法。
 
第一种方法：调用WideCharToMultiByte()和MultiByteToWideChar()，代码如下（关于详细的解释，可以参考《windows核心编程》）：
 

#include <string>
#include <windows.h>
using namespace std;
//Converting a WChar string to a Ansi string
std::string WChar2Ansi(LPCWSTR pwszSrc)
{
         int nLen = WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, NULL, 0, NULL, NULL);
 
         if (nLen<= 0) return std::string("");
 
         char* pszDst = new char[nLen];
         if (NULL == pszDst) return std::string("");
 
         WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, pszDst, nLen, NULL, NULL);
         pszDst[nLen -1] = 0;
 
         std::string strTemp(pszDst);
         delete [] pszDst;
 
         return strTemp;
}

 
string ws2s(wstring& inputws)
{
        return WChar2Ansi(inputws.c_str());
}

 
//Converting a Ansi string to WChar string

std::wstring Ansi2WChar(LPCSTR pszSrc, int nLen)
 
{
    int nSize = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszSrc, nLen, 0, 0);
    if(nSize <= 0) return NULL;
 
         WCHAR *pwszDst = new WCHAR[nSize+1];
    if( NULL == pwszDst) return NULL;
 
    MultiByteToWideChar(CP_ACP, 0,(LPCSTR)pszSrc, nLen, pwszDst, nSize);
    pwszDst[nSize] = 0;
 
    if( pwszDst[0] == 0xFEFF)                    // skip Oxfeff
        for(int i = 0; i < nSize; i ++)
                            pwszDst[i] = pwszDst[i+1];
 
    wstring wcharString(pwszDst);
         delete pwszDst;
 
    return wcharString;
}

 
std::wstring s2ws(const string& s)
{
     return Ansi2WChar(s.c_str(),s.size());
}

 
 
第二种方法：采用ATL封装_bstr_t的过渡：（注，_bstr_是Microsoft Specific的，所以下面代码可以在VS2005通过，无移植性）；

#include <string>
#include <comutil.h>
using namespace std;
#pragma comment(lib, "comsuppw.lib")
 
string ws2s(const wstring& ws);
wstring s2ws(const string& s);
 
string ws2s(const wstring& ws)
{
         _bstr_t t = ws.c_str();
         char* pchar = (char*)t;
         string result = pchar;
         return result;
}

 
wstring s2ws(const string& s)
{
         _bstr_t t = s.c_str();
         wchar_t* pwchar = (wchar_t*)t;
         wstring result = pwchar;
         return result;
}

 
第三种方法：使用CRT库的mbstowcs()函数和wcstombs()函数，平台无关，需设定locale。

#include <string>
#include <locale.h>
using namespace std;
string ws2s(const wstring& ws)
{
         string curLocale = setlocale(LC_ALL, NULL);        // curLocale = "C";
 
         setlocale(LC_ALL, "chs");
 
         const wchar_t* _Source = ws.c_str();
         size_t _Dsize = 2 * ws.size() + 1;
         char *_Dest = new char[_Dsize];
         memset(_Dest,0,_Dsize);
         wcstombs(_Dest,_Source,_Dsize);
         string result = _Dest;
         delete []_Dest;
 
         setlocale(LC_ALL, curLocale.c_str());
 
         return result;
}

 
wstring s2ws(const string& s)
{
         setlocale(LC_ALL, "chs");
 
         const char* _Source = s.c_str();
         size_t _Dsize = s.size() + 1;
         wchar_t *_Dest = new wchar_t[_Dsize];
         wmemset(_Dest, 0, _Dsize);
         mbstowcs(_Dest,_Source,_Dsize);
         wstring result = _Dest;
         delete []_Dest;
 
         setlocale(LC_ALL, "C");
 
         return result;
}

二 utf8.utf16.utf32的相互转化

可以参考Unicode.org 上有ConvertUTF.c和ConvertUTF.h （下载地址：http://www.unicode.org/Public/PROGRAMS/CVTUTF/）

实现文件ConvertUTF.c：（.h省）
/**//*
 * Copyright 2001-2004 Unicode, Inc.
 *
 * Disclaimer
 *
 * This source code is provided as is by Unicode, Inc. No claims are
 * made as to fitness for any particular purpose. No warranties of any
 * kind are expressed or implied. The recipient agrees to determine
 * applicability of information provided. If this file has been
 * purchased on magnetic or optical media from Unicode, Inc., the
 * sole remedy for any claim will be exchange of defective media
 * within 90 days of receipt.
 *
 * Limitations on Rights to Redistribute This Code
 *
 * Unicode, Inc. hereby grants the right to freely use the information
 * supplied in this file in the creation of products supporting the
 * Unicode Standard, and to make copies of this file in any form
 * for internal or external distribution as long as this notice
 * remains attached.
 */

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

    Conversions between UTF32, UTF-16, and UTF-8. Source code file.
    Author: Mark E. Davis, 1994.
    Rev History: Rick McGowan, fixes & updates May 2001.
    Sept 2001: fixed const & error conditions per
    mods suggested by S. Parent & A. Lillich.
    June 2002: Tim Dodd added detection and handling of incomplete
    source sequences, enhanced error detection, added casts
    to eliminate compiler warnings.
    July 2003: slight mods to back out aggressive FFFE detection.
    Jan 2004: updated switches in from-UTF8 conversions.
    Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.

    See the header file "ConvertUTF.h" for complete documentation.

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

#include "ConvertUTF.h"
#ifdef CVTUTF_DEBUG
#include <stdio.h>
#endif

static const int halfShift  = 10; /**//* used for shifting by 10 bits */

static const UTF32 halfBase = 0x0010000UL;
static const UTF32 halfMask = 0x3FFUL;

#define UNI_SUR_HIGH_START  (UTF32)0xD800
#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
#define UNI_SUR_LOW_START   (UTF32)0xDC00
#define UNI_SUR_LOW_END     (UTF32)0xDFFF
#define false       0
#define true        1

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

ConversionResult ConvertUTF32toUTF16 (
    const UTF32** sourceStart, const UTF32* sourceEnd,
    UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF32* source = *sourceStart;
    UTF16* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch;
    if (target >= targetEnd) {
        result = targetExhausted; break;
    }
    ch = *source++;
    if (ch <= UNI_MAX_BMP) { /**//* Target is a character <= 0xFFFF */
        /**//* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        if (flags == strictConversion) {
            --source; /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        } else {
            *target++ = UNI_REPLACEMENT_CHAR;
        }
        } else {
        *target++ = (UTF16)ch; /**//* normal case */
        }
    } else if (ch > UNI_MAX_LEGAL_UTF32) {
        if (flags == strictConversion) {
        result = sourceIllegal;
        } else {
        *target++ = UNI_REPLACEMENT_CHAR;
        }
    } else {
        /**//* target is a character in range 0xFFFF - 0x10FFFF. */
        if (target + 1 >= targetEnd) {
        --source; /**//* Back up source pointer! */
        result = targetExhausted; break;
        }
        ch -= halfBase;
        *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
        *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
    }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

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

ConversionResult ConvertUTF16toUTF32 (
    const UTF16** sourceStart, const UTF16* sourceEnd,
    UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF16* source = *sourceStart;
    UTF32* target = *targetStart;
    UTF32 ch, ch2;
    while (source < sourceEnd) {
    const UTF16* oldSource = source; /**//*  In case we have to back up because of target overflow. */
    ch = *source++;
    /**//* If we have a surrogate pair, convert to UTF32 first. */
    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
        /**//* If the 16 bits following the high surrogate are in the source buffer */
        if (source < sourceEnd) {
        ch2 = *source;
        /**//* If it's a low surrogate, convert to UTF32. */
        if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
            ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
            + (ch2 - UNI_SUR_LOW_START) + halfBase;
            ++source;
        } else if (flags == strictConversion) { /**//* it's an unpaired high surrogate */
            --source; /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        }
        } else { /**//* We don't have the 16 bits following the high surrogate. */
        --source; /**//* return to the high surrogate */
        result = sourceExhausted;
        break;
        }
    } else if (flags == strictConversion) {
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
        --source; /**//* return to the illegal value itself */
        result = sourceIllegal;
        break;
        }
    }
    if (target >= targetEnd) {
        source = oldSource; /**//* Back up source pointer! */
        result = targetExhausted; break;
    }
    *target++ = ch;
    }
    *sourceStart = source;
    *targetStart = target;
#ifdef CVTUTF_DEBUG
if (result == sourceIllegal) {
    fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
    fflush(stderr);
}
#endif
    return result;
}

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

/**//*
 * Index into the table below with the first byte of a UTF-8 sequence to
 * get the number of trailing bytes that are supposed to follow it.
 * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
 * left as-is for anyone who may want to do such conversion, which was
 * allowed in earlier algorithms.
 */
static const char trailingBytesForUTF8[256] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
};

/**//*
 * Magic values subtracted from a buffer value during UTF8 conversion.
 * This table contains as many values as there might be trailing bytes
 * in a UTF-8 sequence.
 */
static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
             0x03C82080UL, 0xFA082080UL, 0x82082080UL };

/**//*
 * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
 * into the first byte, depending on how many bytes follow.  There are
 * as many entries in this table as there are UTF-8 sequence types.
 * (I.e., one byte sequence, two byte etc.). Remember that sequencs
 * for *legal* UTF-8 will be 4 or fewer bytes total.
 */
static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

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

/**//* The interface converts a whole buffer to avoid function-call overhead.
 * Constants have been gathered. Loops & conditionals have been removed as
 * much as possible for efficiency, in favor of drop-through switches.
 * (See "Note A" at the bottom of the file for equivalent code.)
 * If your compiler supports it, the "isLegalUTF8" call can be turned
 * into an inline function.
 */

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

ConversionResult ConvertUTF16toUTF8 (
    const UTF16** sourceStart, const UTF16* sourceEnd,
    UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF16* source = *sourceStart;
    UTF8* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch;
    unsigned short bytesToWrite = 0;
    const UTF32 byteMask = 0xBF;
    const UTF32 byteMark = 0x80;
    const UTF16* oldSource = source; /**//* In case we have to back up because of target overflow. */
    ch = *source++;
    /**//* If we have a surrogate pair, convert to UTF32 first. */
    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
        /**//* If the 16 bits following the high surrogate are in the source buffer */
        if (source < sourceEnd) {
        UTF32 ch2 = *source;
        /**//* If it's a low surrogate, convert to UTF32. */
        if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
            ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
            + (ch2 - UNI_SUR_LOW_START) + halfBase;
            ++source;
        } else if (flags == strictConversion) { /**//* it's an unpaired high surrogate */
            --source; /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        }
        } else { /**//* We don't have the 16 bits following the high surrogate. */
        --source; /**//* return to the high surrogate */
        result = sourceExhausted;
        break;
        }
    } else if (flags == strictConversion) {
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
        --source; /**//* return to the illegal value itself */
        result = sourceIllegal;
        break;
        }
    }
    /**//* Figure out how many bytes the result will require */
    if (ch < (UTF32)0x80) {         bytesToWrite = 1;
    } else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
    } else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
    } else if (ch < (UTF32)0x110000) {  bytesToWrite = 4;
    } else {                bytesToWrite = 3;
                        ch = UNI_REPLACEMENT_CHAR;
    }

    target += bytesToWrite;
    if (target > targetEnd) {
        source = oldSource; /**//* Back up source pointer! */
        target -= bytesToWrite; result = targetExhausted; break;
    }
    switch (bytesToWrite) { /**//* note: everything falls through. */
        case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 1: *--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
    }
    target += bytesToWrite;
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

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

/**//*
 * Utility routine to tell whether a sequence of bytes is legal UTF-8.
 * This must be called with the length pre-determined by the first byte.
 * If not calling this from ConvertUTF8to*, then the length can be set by:
 *  length = trailingBytesForUTF8[*source]+1;
 * and the sequence is illegal right away if there aren't that many bytes
 * available.
 * If presented with a length > 4, this returns false.  The Unicode
 * definition of UTF-8 goes up to 4-byte sequences.
 */

static Boolean isLegalUTF8(const UTF8 *source, int length) {
    UTF8 a;
    const UTF8 *srcptr = source+length;
    switch (length) {
    default: return false;
    /**//* Everything else falls through when "true" */
    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 2: if ((a = (*--srcptr)) > 0xBF) return false;

    switch (*source) {
        /**//* no fall-through in this inner switch */
        case 0xE0: if (a < 0xA0) return false; break;
        case 0xED: if (a > 0x9F) return false; break;
        case 0xF0: if (a < 0x90) return false; break;
        case 0xF4: if (a > 0x8F) return false; break;
        default:   if (a < 0x80) return false;
    }

    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
    }
    if (*source > 0xF4) return false;
    return true;
}

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

/**//*
 * Exported function to return whether a UTF-8 sequence is legal or not.
 * This is not used here; it's just exported.
 */
Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
    int length = trailingBytesForUTF8[*source]+1;
    if (source+length > sourceEnd) {
    return false;
    }
    return isLegalUTF8(source, length);
}

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

ConversionResult ConvertUTF8toUTF16 (
    const UTF8** sourceStart, const UTF8* sourceEnd,
    UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF8* source = *sourceStart;
    UTF16* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch = 0;
    unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
    if (source + extraBytesToRead >= sourceEnd) {
        result = sourceExhausted; break;
    }
    /**//* Do this check whether lenient or strict */
    if (! isLegalUTF8(source, extraBytesToRead+1)) {
        result = sourceIllegal;
        break;
    }
    /**//*
     * The cases all fall through. See "Note A" below.
     */
    switch (extraBytesToRead) {
        case 5: ch += *source++; ch <<= 6; /**//* remember, illegal UTF-8 */
        case 4: ch += *source++; ch <<= 6; /**//* remember, illegal UTF-8 */
        case 3: ch += *source++; ch <<= 6;
        case 2: ch += *source++; ch <<= 6;
        case 1: ch += *source++; ch <<= 6;
        case 0: ch += *source++;
    }
    ch -= offsetsFromUTF8[extraBytesToRead];

    if (target >= targetEnd) {
        source -= (extraBytesToRead+1); /**//* Back up source pointer! */
        result = targetExhausted; break;
    }
    if (ch <= UNI_MAX_BMP) { /**//* Target is a character <= 0xFFFF */
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        if (flags == strictConversion) {
            source -= (extraBytesToRead+1); /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        } else {
            *target++ = UNI_REPLACEMENT_CHAR;
        }
        } else {
        *target++ = (UTF16)ch; /**//* normal case */
        }
    } else if (ch > UNI_MAX_UTF16) {
        if (flags == strictConversion) {
        result = sourceIllegal;
        source -= (extraBytesToRead+1); /**//* return to the start */
        break; /**//* Bail out; shouldn't continue */
        } else {
        *target++ = UNI_REPLACEMENT_CHAR;
        }
    } else {
        /**//* target is a character in range 0xFFFF - 0x10FFFF. */
        if (target + 1 >= targetEnd) {
        source -= (extraBytesToRead+1); /**//* Back up source pointer! */
        result = targetExhausted; break;
        }
        ch -= halfBase;
        *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
        *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
    }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

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

ConversionResult ConvertUTF32toUTF8 (
    const UTF32** sourceStart, const UTF32* sourceEnd,
    UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF32* source = *sourceStart;
    UTF8* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch;
    unsigned short bytesToWrite = 0;
    const UTF32 byteMask = 0xBF;
    const UTF32 byteMark = 0x80;
    ch = *source++;
    if (flags == strictConversion ) {
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        --source; /**//* return to the illegal value itself */
        result = sourceIllegal;
        break;
        }
    }
    /**//*
     * Figure out how many bytes the result will require. Turn any
     * illegally large UTF32 things (> Plane 17) into replacement chars.
     */
    if (ch < (UTF32)0x80) {         bytesToWrite = 1;
    } else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
    } else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
    } else if (ch <= UNI_MAX_LEGAL_UTF32) {  bytesToWrite = 4;
    } else {                bytesToWrite = 3;
                        ch = UNI_REPLACEMENT_CHAR;
                        result = sourceIllegal;
    }
   
    target += bytesToWrite;
    if (target > targetEnd) {
        --source; /**//* Back up source pointer! */
        target -= bytesToWrite; result = targetExhausted; break;
    }
    switch (bytesToWrite) { /**//* note: everything falls through. */
        case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
    }
    target += bytesToWrite;
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

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

ConversionResult ConvertUTF8toUTF32 (
    const UTF8** sourceStart, const UTF8* sourceEnd,
    UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF8* source = *sourceStart;
    UTF32* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch = 0;
    unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
    if (source + extraBytesToRead >= sourceEnd) {
        result = sourceExhausted; break;
    }
    /**//* Do this check whether lenient or strict */
    if (! isLegalUTF8(source, extraBytesToRead+1)) {
        result = sourceIllegal;
        break;
    }
    /**//*
     * The cases all fall through. See "Note A" below.
     */
    switch (extraBytesToRead) {
        case 5: ch += *source++; ch <<= 6;
        case 4: ch += *source++; ch <<= 6;
        case 3: ch += *source++; ch <<= 6;
        case 2: ch += *source++; ch <<= 6;
        case 1: ch += *source++; ch <<= 6;
        case 0: ch += *source++;
    }
    ch -= offsetsFromUTF8[extraBytesToRead];

    if (target >= targetEnd) {
        source -= (extraBytesToRead+1); /**//* Back up the source pointer! */
        result = targetExhausted; break;
    }
    if (ch <= UNI_MAX_LEGAL_UTF32) {
        /**//*
         * UTF-16 surrogate values are illegal in UTF-32, and anything
         * over Plane 17 (> 0x10FFFF) is illegal.
         */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        if (flags == strictConversion) {
            source -= (extraBytesToRead+1); /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        } else {
            *target++ = UNI_REPLACEMENT_CHAR;
        }
        } else {
        *target++ = ch;
        }
    } else { /**//* i.e., ch > UNI_MAX_LEGAL_UTF32 */
        result = sourceIllegal;
        *target++ = UNI_REPLACEMENT_CHAR;
    }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

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

    Note A.
    The fall-through switches in UTF-8 reading code save a
    temp variable, some decrements & conditionals.  The switches
    are equivalent to the following loop:
    {
        int tmpBytesToRead = extraBytesToRead+1;
        do {
        ch += *source++;
        --tmpBytesToRead;
        if (tmpBytesToRead) ch <<= 6;
        } while (tmpBytesToRead > 0);
    }
    In UTF-8 writing code, the switches on "bytesToWrite" are
    similarly unrolled loops.

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

三 C++ 的字符串与C#的转化

1）将system::String 转化为C++的string：
// convert_system_string.cpp
// compile with: /clr
#include <string>
#include <iostream>
using namespace std;
using namespace System;

void MarshalString ( String ^ s, string& os ) {
   using namespace Runtime::InteropServices;
   const char* chars =
      (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

void MarshalString ( String ^ s, wstring& os ) {
   using namespace Runtime::InteropServices;
   const wchar_t* chars =
      (const wchar_t*)(Marshal::StringToHGlobalUni(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

int main() {
   string a = "test";
   wstring b = L"test2";
   String ^ c = gcnew String("abcd");

   cout << a << endl;
   MarshalString(c, a);
   c = "efgh";
   MarshalString(c, b);
   cout << a << endl;
   wcout << b << endl;
}

2）将System::String转化为char*或w_char*
// convert_string_to_wchar.cpp
// compile with: /clr
#include < stdio.h >
#include < stdlib.h >
#include < vcclr.h >

using namespace System;

int main() {
   String ^str = "Hello";

   // Pin memory so GC can't move it while native function is called
   pin_ptr<const wchar_t> wch = PtrToStringChars(str);
   printf_s("%S\n", wch);

   // Conversion to char* :
   // Can just convert wchar_t* to char* using one of the
   // conversion functions such as:
   // WideCharToMultiByte()
   // wcstombs_s()
   //  etc
   size_t convertedChars = 0;
   size_t  sizeInBytes = ((str->Length + 1) * 2);
   errno_t err = 0;
   char    *ch = (char *)malloc(sizeInBytes);

   err = wcstombs_s(&convertedChars,
                    ch, sizeInBytes,
                    wch, sizeInBytes);
   if (err != 0)
      printf_s("wcstombs_s  failed!\n");

    printf_s("%s\n", ch);
}

二、在Linux下如何使用软盘、光盘以及DOS等非Linux分区

　　装载的命令是mount，格式如下：mount -t 文件系统类型 设备名 装载目录

　　文件系统类型就是分区格式，Linux支持的文件系统类型有许多：

　　msdos DOS分区文件系统类型
　　vfat 支持长文件名的DOS分区文件（可以理解为Windows文件）系统类型
　　iso9660 光盘的文件系统类型
　　ext2 Linux的文件系统类型

　　设备名，指的是你要装载的设备的名称。软盘一般为/dev/fd0 fd1；光盘则根据你的光驱的位置来决定，通常光驱装在第二硬盘的主盘位置就是/dev/hdc;如果访问的是DOS的分区，则列出其设备名，如/dev/hda1是指第一硬盘的第一个分区。 装载目录，就是你指定设备的载入点。

　　1. 装载软盘

　　首先用mkdir /mnt/floppy 在/mnt目录下建立一个空的floppy目录，然后输入mount -t msdos /dev/fd0 /mnt/floppy 将DOS文件格式的一张软盘装载进来，以后就可以在/mnt/floppy目录下找到这张软盘的所有内容。

　　2. 装载Windows所在的C盘

　　mkdir /mnt/c 在/mnt目录下建立一个空的c目录;
　　mount -t vfat /dev/hda1 /mnt/c 将Windows的C盘按长文件名格式装载到/mnt/c目录下，以后在该目录下就能读写C盘根目录中的内容。

　　3.装载光盘

　　mkdir /mnt/cdrom 在/mnt目录下建立一个空的cdrom目录;
　　mount -t iso9660 /dev/hdc /mnt/cdrom 将光盘载入到文件系统中来，将在/mnt/cdrom目录下找到光盘内容。有的Linux版本允许用mount /dev/cdrom或mount /mnt/cdrom命令装载光盘。
　　要注意的是，用mount命令装入的是软盘、光盘，而不是软驱、光驱。有些初学者容易犯一个毛病，以为用上面命令后，软驱就成了/mnt/floppy，光驱就成了/mnt/cdrom，其实不然，当你要换一张光盘或软盘时，一定要先卸载，再对新盘重新装载。

　　4.卸载

　　卸载的命令格式是:umonut 目录名，例如要卸载软盘，可输入命令umonut /mnt/floppy。要注意的是，在卸载光盘之前，直接按光驱面板上的弹出键是不会起作用的。

三、RPM的使用方法

1. 用RPM安装软件包 ：rpm -ivh 软件文件名
　　例如 rpm -ivh fvwm95-2.0.43a.chinese-1.i386.rpm 屏幕上就会输出该软件包的名称和安装的进度条:
　　fvwm95 ###############
　　当进度条走到底，中文fvwm95（一种X-Window的界面）就安装完了，再运行X-Window，啊，全中文的fvwm95就在我的眼前。

2. 用RPM反安装软件包:rpm -e 软件名
　　例如:rpm -e fvwm95

3. 用RPM升级软件包:rpm -Uvh 软件升级版文件名
　　例如:rpm -Uvh fvwm95-2.1.0a.chinese-1.i386.rpm，RPM自动反安装原来的老版本，将升级版的软件安装入系统。

四、Linux开机直接进入文本界面，怎样才能让它默认进入图形界面？

修改/etc/inittab文件，其中有一行id:3:initdefault，意思是说开机默认进入运行级别3（多用户的文本界面），把它改成id:5:initdefault，既开机默认进入运行级别5（多用户的图形界面）。这样就行了。

五、如何将man转存为文本文件？

以ls的man为例
man ls |col -b >ls.txt
将info变成文本,以make为例
info make -o make.txt -s

六、如何将将 man page 转成 HTML 格式？

使用 man2html 这个指令，就可以将 man page 转成 HTML 格式了。用法是：

man2html filename > htmlfile.html

七、.tar，.tar.gz，.bz2，.tar.bz2，.bz，.gz是什么文件，如何解开他们？
他们都是文件(压缩)包。
.tar：把文件打包，不压缩：tar cvf *.tar dirName 解开：tar xvf *.tar
.tar.gz：把文件打包并压缩：tar czvf *.tar.gz dirName 解开：tar xzvf *.tar.gz
.bz2：解开：bzip2 -d *.bz2
.bz：解开：bzip -d *.bz
.gz：解开：gzip -d *.gz

八、linux下如何解开.zip，.rar压缩文件？
rh8下有一个图形界面的软件file-roller可以做这件事。令外可以用unzip *.zip解开zip文件，unrar *.rar解开rar文件，不过unrar一般系统不自带，要到网上下载。

九、linux下如何浏览.iso光盘镜像文件？
a.建一个目录，如：mkdir a
b.把iso文件挂载到该目录上：mount -o loop xxxx.iso a
现在目录a里的内容就是iso文件里的内容了。

十、linux下如何配置网络？
用netconfig。“IP address:”就是要配置的IP地址，“Netmask:”子网掩码，“Default gateway (IP):”网关，“Primary nameserver:”DNS服务器IP

十一、如何让linux启动后自动挂载制定分区？
编辑/etc/fstab文件，在里面加入相应的行

十二、如何定制linux启动时启动的服务？
在控制台或终端下运行ntsysv，然后把要启动的服务选上，如果要开机不启动某个那就把他的选中去掉。

十三、删除文件大小为零的文件
rm -i `find ./ -size 0`
find ./ -size 0 -exec rm {} \;
find ./ -size |xargs rm -f &非常有效
for file in * #自己定义需要删除的文件类型
do
if [ ! -s ${file} ]
then
rm ${file}
echo “rm $file Success!”
fi
done

十四、查看系统信息
cat /proc/cpuinfo - CPU (i.e. vendor, Mhz, flags like mmx)
cat /proc/interrupts - 中断
cat /proc/ioports - 设备IO端口
cat /proc/meminfo - 内存信息(i.e. mem used, free, swap size)
cat /proc/partitions - 所有设备的所有分区
cat /proc/pci - PCI设备的信息
cat /proc/swaps - 所有Swap分区的信息
cat /proc/version - Linux的版本号 相当于 uname -r
uname -a - 看系统内核等信息

十五、cd光盘做成iso文件
cp /dev/cdrom xxxx.iso

十六、快速观看开机的硬件检测
dmesg | more

十七、查看硬盘的使用情况
df -k 以K为单位显示
df -h 以人性化单位显示，可以是b,k,m,g,t..

十八、查看目录的大小
du -sh dirname
-s 仅显示总计
-h 以K、M、G为单位，提高信息的可读性。KB、MB、GB是以1024为换算单位，-H以1000为换算单位。

十九、查找或删除正在使用某文件的进程
fuser filename
fuser -k filename

二十、字符模式下设置/删除环境变量
bash下
设置：export 变量名=变量值
删除：unset 变量名
csh下
设置：setenv 变量名 变量值
删除：unsetenv 变量名

二十一、vim中显示颜色或不显示颜色
vi ~/.vimrc; 如果有syntax on，则显示颜色，syntax off，则不显示颜色

二十二、修改系统时间
date -s “2003-04-14 cst”，cst指时区，时间设定用date -s 18:10

二十三、开机就mount上windows下的分区
自动将windows的d盘挂到/mnt/d上，用vi打开/etc/fstab，加入以下一行
/dev/hda5 /mnt/d vfat defaults,codepage=936,iocharset=cp936 0 0
注意，先得手工建立一个/mnt/d目录

二十四、在多级目录中查找某个文件的方法
find /dir -name filename.ext
du -a | grep filename.ext
locate filename.ext

二十五、不让普通用户自己改密码
[root@xin_fc etc]# chmod 511 /usr/bin/passwd
又想让普通用户自己改密码
[root@xin_fc etc]# chmod 4511 /usr/bin/passwd

二十六、用dd做iso
dd if=/dev/cdrom of=/tmp/aaa.iso

二十七、让Linux自动同步时间
vi /etc/crontab
加上一句
00 0 1 * * root rdate -s time.nist.gov

二十八、ssh上来能不能不自动断线
那是timetou的设置，修改TMOUT变量值

二十九、监视所有通过本机网卡的数据
tcpdump iptraf

AWK是一种优良的文本处理工具。它不仅是 Linux 中也是任何环境中现有的功能最强大的数据处理发动机之一。这种编程及数据操作语言（其名称得自于它的创始人 Alfred Aho 、Peter Weinberger 和 Brian Kernighan 姓氏的首个字母）的最大功能取决于一个人所拥有的知识。 AWK 提供了极其强大的功能：可以进行样式装入、流控制、数学运算符、进程控制语句甚至于内置的变量和函数。它具备了一个完整的语言所应具有的几乎所有精美特性。实际上 AWK 的确拥有自己的语言： AWK 程序设计语言，三位创建者已将它正式定义为“样式扫描和处理语言”。它允许您创建简短的程序，这些程序读取输入文件、为数据排序、处理数据、对输入执行计算以及生成报表，还有无数其他的功能。

      你可能对UNIX比较熟悉，但你可能对awk很陌生，这一点也不奇怪，的确，与其优秀的功能相比，awk还远没达到它应有的知名度。awk是什么？与其它大多数UNIX命令不同的是，从名字上看，我们不可能知道awk的功能：它既不是具有独立意义的英文单词，也不是几个相关单词的缩写。事实上，awk是三个人名的缩写，他们是：Aho、(Peter)Weinberg和 (Brain)Kernighan。正是这三个人创造了awk—一个优秀的样式扫描与处理工具。

　  　最简单地说， AWK 是一种用于处理文本的编程语言工具。AWK 在很多方面类似于 shell 编程语言，尽管 AWK 具有完全属于其本身的语法。它的设计思想来源于 SNOBOL4 、sed 、Marc Rochkind设计的有效性语言、语言工具 yacc 和 lex ，当然还从 C 语言中获取了一些优秀的思想。在最初创造 AWK 时，其目的是用于文本处理，并且这种语言的基础是，只要在输入数据中有模式匹配，就执行一系列指令。该实用工具扫描文件中的每一行，查找与命令行中所给定内容相匹配的模式。如果发现匹配内容，则进行下一个编程步骤。如果找不到匹配内容，则继续处理下一行。

　  　尽管操作可能会很复杂，但命令的语法始终是：

　  　awk ‘{pattern + action}’ {filenames}

　  　其中 pattern 表示 AWK 在数据中查找的内容，而 action 是在找到匹配内容时所执行的一系列命令。花括号 ({}) 不需要在程序中始终出现，但它们用于根据特定的模式对一系列指令进行分组。

　  　gawk 是 AWK 的 GNU 版本。

一、AWK的功能是什么？

      与sed和 grep很相似，awk是一种样式扫描与处理工具。但其功能却大大强于sed和grep。awk提供了极其强大的功能：它几乎可以完成grep和sed所能完成的全部工作，同时，它还可以可以进行样式装入、流控制、数学运算符、进程控制语句甚至于内置的变量和函数。它具备了一个完整的语言所应具有的几乎所有精美特性。实际上，awk的确拥有自己的语言：awk程序设计语言，awk的三位创建者已将它正式定义为：样式扫描和处理语言。

二、为什么使用awk?

      即使如此，你也许仍然会问，我为什么要使用awk?

      使用awk的第一个理由是基于文本的样式扫描和处理是我们经常做的工作，awk所做的工作有些象数据库，但与数据库不同的是，它处理的是文本文件，这些文件没有专门的存储格式，普通的人们就能编辑、阅读、理解和处理它们。而数据库文件往往具有特殊的存储格式，这使得它们必须用数据库处理程序来处理它们。既然这种类似于数据库的处理工作我们经常会遇到，我们就应当找到处理它们的简便易行的方法，UNIX有很多这方面的工具，例如sed 、grep、sort以及find等等，awk是其中十分优秀的一种。

      使用awk的第二个理由是awk是一个简单的工具，当然这是相对于其强大的功能来说的。的确，UNIX有许多优秀的工具，例如UNIX天然的开发工具C语言及其延续C++就非常的优秀。但相对于它们来说，awk完成同样的功能要方便和简捷得多。这首先是因为awk提供了适应多种需要的解决方案：从解决简单问题的awk命令行到复杂而精巧的awk程序设计语言，这样做的好处是，你可以不必用复杂的方法去解决本来很简单的问题。例如，你可以用一个命令行解决简单的问题，而C不行，即使一个再简单的程序，C语言也必须经过编写、编译的全过程。其次，awk本身是解释执行的，这就使得awk程序不必经过编译的过程，同时，这也使得它与shell script程序能够很好的契合。最后，awk本身较C语言简单，虽然awk吸收了C语言很多优秀的成分，熟悉C语言会对学习awk有很大的帮助，但 awk本身不须要会使用C语言——一种功能强大但需要大量时间学习才能掌握其技巧的开发工具。

       使用awk的第三个理由是awk是一个容易获得的工具。与C和C++语言不同，awk只有一个文件(/bin/awk)，而且几乎每个版本的UNIX都提供各自版本的awk，你完全不必费心去想如何获得awk。但C语言却不是这样，虽然C语言是UNIX天然的开发工具，但这个开发工具却是单独发行的，换言之，你必须为你的UNIX版本的C语言开发工具单独付费（当然使用D版者除外），获得并安装它，然后你才可以使用它。

      基于以上理由，再加上awk强大的功能，我们有理由说，如果你要处理与文本样式扫描相关的工作，awk应该是你的第一选择。在这里有一个可遵循的一般原则：如果你用普通的shell工具或shell script有困难的话，试试awk,如果awk仍不能解决问题，则便用C语言，如果C语言仍然失败，则移至C++。

三、awk的调用方式

      前面曾经说过，awk提供了适应多种需要的不同解决方案，它们是：

      1、 awk命令行，你可以象使用普通UNIX命令一样使用awk，在命令行中你也可以使用awk程序设计语言，虽然awk支持多行的录入，但是录入长长的命令行并保证其正确无误却是一件令人头疼的事，因此，这种方法一般只用于解决简单的问题。当然，你也可以在shell script程序中引用awk命令行甚至awk程序脚本。

      2、使用-f选项调用awk程序。awk允许将一段awk程序写入一个文本文件，然后在awk命令行中用-f选项调用并执行这段程序。具体的方法我们将在后面的awk语法中讲到。

      3、利用命令解释器调用awk程序：利用UNIX支持的命令解释器功能，我们可以将一段awk程序写入文本文件，然后在它的第一行加上:
#!/bin/awk -f
并赋予这个文本文件以执行的权限。这样做之后，你就可以在命令行中用类似于下面这样的方式调用并执行这段awk程序了。

$awk脚本文本名 待处理文件

awk的语法：

与其它UNIX命令一样，awk拥有自己的语法：

awk [ -F re] [parameter…] [’prog’] [-f progfile][in_file…]

参数说明：

-F re:允许awk更改其字段分隔符。

parameter: 该参数帮助为不同的变量赋值。

‘prog’: awk的程序语句段。这个语句段必须用单拓号：’和’括起，以防被shell解释。这个程序语句段的标准形式为：

‘pattern {action}’

      其中pattern参数可以是egrep正则表达式中的任何一个，它可以使用语法/re/再加上一些样式匹配技巧构成。与sed类似，你也可以使用”,”分开两样式以选择某个范围。关于匹配的细节，你可以参考附录，如果仍不懂的话，找本UNIX书学学grep和sed（本人是在学习ed时掌握匹配技术的）。 action参数总是被大括号包围，它由一系统awk语句组成，各语句之间用”;”分隔。awk解释它们，并在pattern给定的样式匹配的记录上执行其操作。与shell类似，你也可以使用“#”作为注释符，它使“#”到行尾的内容成为注释，在解释执行时，它们将被忽略。你可以省略pattern和 action之一，但不能两者同时省略，当省略pattern时没有样式匹配，表示对所有行（记录）均执行操作，省略action时执行缺省的操作——在标准输出上显示。

      -f progfile:允许awk调用并执行progfile指定有程序文件。progfile是一个文本文件，他必须符合awk的语法。

      in_file:awk的输入文件，awk允许对多个输入文件进行处理。值得注意的是awk不修改输入文件。如果未指定输入文件，awk将接受标准输入，并将结果显示在标准输出上。awk支持输入输出重定向。

      awk的记录、字段与内置变量：

      前面说过，awk处理的工作与数据库的处理方式有相同之处，其相同处之一就是awk支持对记录和字段的处理，其中对字段的处理是grep和sed不能实现的，这也是awk优于二者的原因之一。在awk中，缺省的情况下总是将文本文件中的一行视为一个记录，而将一行中的某一部分作为记录中的一个字段。为了操作这些不同的字段，awk借用shell的方法，用$1,$2,$3…这样的方式来顺序地表示行（记录）中的不同字段。特殊地，awk用$0表示整个行（记录）。不同的字段之间是用称作分隔符的字符分隔开的。系统默认的分隔符是空格。awk允许在命令行中用-F re的形式来改变这个分隔符。事实上，awk用一个内置的变量FS来记忆这个分隔符。awk中有好几个这样的内置变量，例如，记录分隔符变量RS、当前工作的记录数NR等等，本文后面的附表列出了全部的内置变量。这些内置的变量可以在awk程序中引用或修改，例如，你可以利用NR变量在模式匹配中指定工作范围，也可以通过修改记录分隔符RS让一个特殊字符而不是换行符作为记录的分隔符。

      例:显示文本文件myfile中第七行到第十五行中以字符%分隔的第一字段，第三字段和第七字段：

awk -F % ‘NR==7,NR==15 {printf $1 $3 $7}’

四、awk的内置函数

      awk 之所以成为一种优秀的程序设计语言的原因之一是它吸收了某些优秀的程序设计语言（例如C）语言的许多优点。这些优点之一就是内置函数的使用，awk定义并支持了一系列的内置函数，由于这些函数的使用，使得awk提供的功能更为完善和强大，例如，awk使用了一系列的字符串处理内置函数(这些函数看起来与C 语言的字符串处理函数相似，其使用方式与C语言中的函数也相差无几)，正是由于这些内置函数的使用，使awk处理字符串的功能更加强大。本文后面的附录中列有一般的awk所提供的内置函数，这些内置函数也许与你的awk版本有些出入，因此，在使用之前，最好参考一下你的系统中的联机帮助。

      作为内置函数的一个例子，我们将在这里介绍awk的printf函数，这个函数使得awk与c语言的输出相一致。实际上，awk中有许多引用形式都是从C语言借用过来的。如果你熟悉C语言，你也许会记得其中的printf函数，它提供的强大格式输出功能曾经带我们许多的方便。幸运的是，我们在awk中又和它重逢了。awk中printf几乎与C语言中一模一样，如果你熟悉C语言的话，你完全可以照C语言的模式使用awk中的printf。因此在这里，我们只给出一个例子，如果你不熟悉的话，请随便找一本C语言的入门书翻翻。

例:显示文件myfile中的行号和第3字段：

$awk ‘{printf”%03d%sn”,NR,$1}’ myfile

五、在命令行使用awk

      按照顺序，我们应当讲解awk程序设计的内容了，但在讲解之前，我们将用一些例子来对前面的知识进行回顾，这些例子都是在命令行中使用的，由此我们可以知道在命令行中使用awk是多么的方便。这样做的原因一方面是为下面的内容作铺垫，另一方面是介绍一些解决简单问题的方法，我们完全没有必要用复杂的方法来解决简单的问题—-既然awk提供了较为简单的方法的话。

例：显示文本文件mydoc匹配（含有）字符串”sun”的所有行。

$awk ‘/sun/{print}’ mydoc

      由于显示整个记录（全行）是awk的缺省动作，因此可以省略action项。

$awk ‘/sun/’ mydoc

例：下面是一个较为复杂的匹配的示例：

$awk ‘/[Ss]un/,/[Mm]oon/ {print}’ myfile

      它将显示第一个匹配Sun或sun的行与第一个匹配Moon或moon的行之间的行，并显示到标准输出上。

例：下面的示例显示了内置变量和内置函数length（）的使用：

$awk ‘length($0)>80 {print NR}’ myfile

      该命令行将显示文本myfile中所有超过80个字符的行号，在这里，用$0表示整个记录（行），同时，内置变量NR不使用标志符’$'。

例：作为一个较为实际的例子，我们假设要对UNIX中的用户进行安全性检查，方法是考察/etc下的passwd文件，检查其中的passwd字段（第二字段）是否为”*”，如不为”*”，则表示该用户没有设置密码，显示出这些用户名（第一字段）。我们可以用如下语句实现：

#awk -F: ‘$2==”" {printf(”%s no password!n”,$1′ /etc/passwd

      在这个示例中，passwd文件的字段分隔符是“：”，因此，必须用-F：来更改默认的字段分隔符，这个示例中也涉及到了内置函数printf的使用。

六、awk的变量

      如同其它程序设计语言一样，awk允许在程序语言中设置变量，事实上，提供变量的功能是程序设计语言的其本要求，不提供变量的程序设计语言本人还从未见过。

      awk 提供两种变量，一种是awk内置的变量，这前面我们已经讲过，需要着重指出的是，与后面提到的其它变量不同的是，在awk程序中引用内置变量不需要使用标志符”$”（回忆一下前面讲过的NR的使用）。awk提供的另一种变量是自定义变量。awk允许用户在awk程序语句中定义并调用自已的变量。当然这种变量不能与内置变量及其它awk保留字相同，在awk中引用自定义变量必须在它前面加上标志符”$”。与C语言不同的是，awk中不需要对变量进行初始化， awk根据其在awk中第一次出现的形式和上下文确定其具体的数据类型。当变量类型不确定时，awk默认其为字符串类型。这里有一个技巧：如果你要让你的 awk程序知道你所使用的变量的明确类型，你应当在在程序中给它赋初值。在后面的实例中，我们将用到这一技巧。

七、运算与判断

      作为一种程序设计语言所应具有的特点之一，awk支持多种运算，这些运算与C语言提供的几本相同：如+、-、*、/、%等等，同时，awk也支持C语言中类似++、–、+=、-=、=+、=-之类的功能，这给熟悉C语言的使用者编写awk程序带来了极大的方便。作为对运算功能的一种扩展，awk还提供了一系列内置的运算函数（如log、sqr、cos、sin等等）和一些用于对字符串进行操作（运算）的函数（如length、substr等等）。这些函数的引用大大的提高了awk的运算功能。

      作为对条件转移指令的一部分，关系判断是每种程序设计语言都具备的功能，awk也不例外。 awk中允许进行多种测试，如常用的==（等于）、！=（不等于）、>（大于）、<（小于）、>=（大于等于）、>=（小于等于）等等，同时，作为样式匹配，还提供了~（匹配于）和！~（不匹配于）判断。

       作为对测试的一种扩充，awk也支持用逻辑运算符:!(非)、&&（与）、||（或）和括号（）进行多重判断，这大大增强了awk的功能。本文的附录中列出了awk所允许的运算、判断以及操作符的优先级。

八、awk的流程控制

      流程控制语句是任何程序设计语言都不能缺少的部分。任何好的语言都有一些执行流程控制的语句。awk提供的完备的流程控制语句类似于C语言，这给我们编程带来了极大的方便。

1、BEGIN和END:

      在awk 中两个特别的表达式，BEGIN和END，这两者都可用于pattern中（参考前面的awk语法），提供BEGIN和END的作用是给程序赋予初始状态和在程序结束之后执行一些扫尾的工作。任何在BEGIN之后列出的操作（在{}内）将在awk开始扫描输入之前执行，而END之后列出的操作将在扫描完全部的输入之后执行。因此，通常使用BEGIN来显示变量和预置（初始化）变量，使用END来输出最终结果。

      例：累计销售文件xs中的销售金额（假设销售金额在记录的第三字段）：

$awk
>’BEGIN { FS=”:”;print “统计销售金额”;total=0}
>{print $3;total=total+$3;}
>END {printf “销售金额总计：%.2f”,total}’ sx
（注：>是shell提供的第二提示符，如要在shell程序awk语句和awk语言中换行，则需在行尾加反斜杠）

      在这里，BEGIN预置了内部变量FS（字段分隔符）和自定义变量total,同时在扫描之前显示出输出行头。而END则在扫描完成后打印出总合计。

      2、流程控制语句

      awk提供了完备的流程控制语句，其用法与C语言类似。下面我们一一加以说明：

2.1、if…else语句:

格式：
if(表达式)
语句1
else
语句2

格式中”语句1″可以是多个语句，如果你为了方便awk判断也方便你自已阅读，你最好将多个语句用{}括起来。awk分枝结构允许嵌套，其格式为：

if(表达式1）
{if(表达式2）
语句1
else
语句2
}
语句3
else {if(表达式3)
语句4
else
语句5
}
语句6

当然实际操作过程中你可能不会用到如此复杂的分枝结构，这里只是为了给出其样式罢了。

2.2、while语句

格式为:

while(表达式)
语句

2.3、do-while语句

格式为:

do
{
语句
}while(条件判断语句）

2.4、for语句

格式为：

for(初始表达式;终止条件;步长表达式)
{语句}

      在awk 的 while、do-while和for语句中允许使用break,continue语句来控制流程走向，也允许使用exit这样的语句来退出。break 中断当前正在执行的循环并跳到循环外执行下一条语句。continue从当前位置跳到循环开始处执行。对于exit的执行有两种情况：当exit语句不在 END中时，任何操作中的exit命令表现得如同到了文件尾，所有模式或操作执行将停止，END模式中的操作被执行。而出现在END中的exit将导致程序终止。

例：为了

九、awk中的自定义函数

      定义和调用用户自己的函数是几乎每个高级语言都具有的功能，awk也不例外，但原始的awk并不提供函数功能，只有在nawk或较新的awk版本中才可以增加函数。

函数的使用包含两部分：函数的定义与函数调用。其中函数定义又包括要执行的代码（函数本身）和从主程序代码传递到该函数的临时调用。

awk函数的定义方法如下：

function 函数名(参数表){
函数体
}

      在gawk中允许将function省略为func，但其它版本的awk不允许。函数名必须是一个合法的标志符，参数表中可以不提供参数（但在调用函数时函数名后的一对括号仍然是不可缺少的），也可以提供一个或多个参数。与C语言相似，awk的参数也是通过值来传递的。

      在awk 中调用函数比较简单，其方法与C语言相似，但awk比C语言更为灵活，它不执行参数有效性检查。换句话说，在你调用函数时，可以列出比函数预计（函数定义中规定）的多或少的参数，多余的参数会被awk所忽略，而不足的参数，awk将它们置为缺省值0或空字符串，具体置为何值，将取决于参数的使用方式。

      awk函数有两种返回方式：隐式返回和显式返回。当awk执行到函数的结尾时，它自动地返回到调用程序，这是函数是隐式返回的。如果需要在结束之前退出函数，可以明确地使用返回语句提前退出。方法是在函数中使用形如：return 返回值 格式的语句。

      例：下面的例子演示了函数的使用。在这个示例中，定义了一个名为print_header的函数，该函数调用了两个参数FileName和PageNum， FileName参数传给函数当前使用的文件名，PageNum参数是当前页的页号。这个函数的功能是打印（显示）出当前文件的文件名，和当前页的页号。完成这个功能后，这个函数将返回下一页的页号。

nawk
>’BEGIN{pageno=1;file=FILENAME
>pageno=print_header(file，pageno)；#调用函数print_header
>printf(”当前页页号是：%dn”,pageno);
>}

>#定义函数print_header
>function print_header(FileName,PageNum){
>printf(”%s %dn”,FileName,PageNum); >PageNum++;return PageNUm;
>}
>}’ myfile

      执行这个程序将显示如下内容：

myfile 1
当前页页号是：2

十、awk高级输入输出

      1.读取下一条记录：

      awk的next语句导致awk读取下一个记录并完成模式匹配，然后立即执行相应的操作。通常它用匹配的模式执行操作中的代码。next导致这个记录的任何额外匹配模式被忽略。

      2.简单地读取一条记录

      awk 的 getline语句用于简单地读取一条记录。如果用户有一个数据记录类似两个物理记录，那么getline将尤其有用。它完成一般字段的分离(设置字段变量$0 FNR NF NR)。如果成功则返回1，失败则返回0（到达文件尾）。如果需简单地读取一个文件，则可以编写以下代码：

例：示例getline的使用

{while(getline==1)
{
#process the inputted fields
}
}

      也可以使getline保存输入数据在一个字段中，而不是通过使用getline variable的形式处理一般字段。当使用这种方式时，NF被置成0，FNR和NR被增值。

      用户也可以使用getline<"filename"方式从一个给定的文件中输入数据，而不是从命令行所列内容输入数据。此时，getline将完成一般字段分离（设置字段变量$0和NF)。如果文件不存在，返回-1,成功，返回1,返回0表示失败。用户可以从给定文件中读取数据到一个变量中，也可以用stdin(标准输入设备）或一个包含这个文件名的变量代替filename。值得注意的是当使用这种方式时不修改FNR和NR。

      另一种使用getline语句的方法是从UNIX命令接受输入，例如下面的例子:

例：示例从UNIX命令接受输入

{while("who -u"|getline)
{
#process each line from the who command
}
}

当然，也可以使用如下形式:

"command" | getline variable

      3.关闭文件:

      awk中允许在程序中关闭一个输入或输出文件，方法是使用awk的close语句。

close("filename"t

      filename可以是getline打开的文件（也可以是stdin,包含文件名的变量或者getline使用的确切命令）。或一个输出文件（可以是stdout，包含文件名的变量或使用管道的确切命令）。

      4.输出到一个文件:

awk中允许用如下方式将结果输出到一个文件：

printf("hello word!n"t>“datafile”
或
printf(”hello word!n”t>>”datafile”

      5.输出到一个命令

awk中允许用如下方式将结果输出到一个命令：

printf(”hello word!n”t|”sort-t’,'”

十一、awk与shell script混合编程

      因为awk可以作为一个shell命令使用，因此awk能与shell批处理程序很好的融合在一起，这给实现awk与shell程序的混合编程提供了可能。实现混合编程的关键是awk与shell script之间的对话，换言之，就是awk与shell script之间的信息交流:awk从shell script中获取所需的信息（通常是变量的值）、在awk中执行shell命令行、shell script将命令执行的结果送给awk处理以及shell script读取awk的执行结果等等。

1.awk读取Shell script程序变量

在awk中我们可以通过“’$变量名’”的方式读取sell scrpit程序中的变量。

例：在下面的示例中，我们将读取sell scrpit程序中的变量Name，该变量存放的是文本myfile的撰写者，awk将打印出这个人名。

$cat writename
:
# @(#)
#
.
.
.
Name=”张三” nawk ‘BEGIN {name=”‘Name’”; printf(”t%st撰写者%sn”,FILENAME,name”t;}
{…}END{…}’ myfile
.
.
.

2.将shell命令的执行结果送给awk处理

作为信息传送的一种方法，我们可以将一条shell命令的结果通过管道线（|）传递给awk处理：

例：示例awk处理shell命令的执行结果

$who -u | awk ‘{printf(”%s正在执行%sn”,$2,$1)}’

该命令将打印出注册终端正在执行的程序名。

3.shell script程序读awk的执行结果

为了实现shell script程序读取awk执行的结果，我们可以采取一些特殊的方法，例如我们可以用变量名=`awk语句`的形式将awk执行的结果存放入一个 shell script变量。当然也可以用管道线的方法将awk执行结果传递给shell script程序处理。

例：作为传送消息的机制之一，UNIX提供了一个向其所有用户传送消息的命令wall（意思是write to all写给所有用户），该命令允许向所有工作中的用户（终端）发送消息。为此，我们可以通过一段shell批处理程序wall.shell来模拟这一程序（事实上比较老的版本中wall就是一段shell批处理程序：

$cat wall.shell
:
# @(#) wall.shell:发送消息给每个已注册终端
#
cat >/tmp/$$
#用户录入消息文本 who -u | awk ‘{print $2}’ | while read tty
do
cat /tmp/$$>$tty
done

在这个程序里，awk接受who -u命令的执行结果，该命令打印出所有已注册终端的信息，其中第二个字段是已注册终端的设备名，因此用awk命令析出该设备名，然后用while read tty语句循环读出这些文件名到变量（shell script变量）tty中，作为信息传送的终结地址。

4.在awk中执行shell命令行—-嵌入函数system()

system()是一个不适合字符或数字类型的嵌入函数，该函数的功能是处理作为参数传递给它的字符串。system对这个参数的处理就是将其作为命令处理，也就是说将其当作命令行一样加以执行。这使得用户在自己的awk程序需要时可以灵活地执行命令或脚本。

例：下面的程序将使用system嵌入函数打印用户编制好的报表文件，这个文件存放在名为myreport.txt的文件中。为简约起见，我们只列出了其END部分：

.
.
.
END {close(”myreport.txt”t;system(”lp myreport.txt”t;}

在这个示例中，我们首先使用close语句关闭了文件myreport.txt文件，然后使用system嵌入函数将myreport.txt送入打印机打印。

写到这里，我不得不跟朋友们说再见了，实在地说，这些内容仍然是awk的初步知识，电脑永远是前进的科学，awk也不例外，本篇所能做的只是在你前行的漫漫长途中铺平一段小小开端，剩下的路还得靠你自己去走。老实说，如果本文真能给你前行的路上带来些许的方便，那本人就知足了！

如对本篇有任何疑问，请E-mail To:Chizlong@yeah.net或到主页http://chizling.yeah.net中留言。
附录：

1.awk的常规表达式元字符

换码序列
^ 在字符串的开头开始匹配
$ 在字符串的结尾开始匹配
. 与任何单个字符串匹配
[ABC] 与[]内的任一字符匹配
[A-Ca-c] 与A-C及a-c范围内的字符匹配（按字母表顺序）
[^ABC] 与除[]内的所有字符以外的任一字符匹配
Desk|Chair 与Desk和Chair中的任一个匹配
[ABC][DEF] 关联。与A、B、C中的任一字符匹配，且其后要跟D、E、F中的任一个字符。
* 与A、B或C中任一个出现0次或多次的字符相匹配
+ 与A、B或C中任何一个出现1次或多次的字符相匹配
？ 与一个空串或A、B或C在任何一个字符相匹配
（Blue|Black）berry 合并常规表达式，与Blueberry或Blackberry相匹配

2.awk算术运算符

运算符 用途
——————
x^y x的y次幂
x**y 同上
x%y 计算x/y的余数（求模）
x+y x加y
x-y x减y
x*y x乘y
x/y x除y
-y 负y(y的开关符号);也称一目减
++y y加1后使用y(前置加）
y++ 使用y值后加1（后缀加）
–y y减1后使用y(前置减）
y– 使用后y减1(后缀减）
x=y 将y的值赋给x
x+=y 将x+y的值赋给x
x-=y 将x-y的值赋给x
x*=y 将x*y的值赋给x
x/=y 将x/y的值赋给x x%=y 将x%y的值赋给x
x^=y 将x^y的值赋给x
x**=y 将x**y的值赋给x

3.awk允许的测试：

操作符 含义

x==y x等于y
x!=y x不等于y
x>y x大于y
x>=y x大于或等于y
xx<=y x小于或等于y?
x~re x匹配正则表达式re?
x!~re x不匹配正则表达式re?

4.awk的操作符(按优先级升序排列)

= 、+=、 -=、 *= 、/= 、 %=
||
&&
> >= < <= == != ~ !~
xy (字符串连结，’x'’y'变成”xy”）
+ -
* / %
++ –

5.awk内置变量（预定义变量）

说明：表中v项表示第一个支持变量的工具（下同）：A=awk，N=nawk,P=POSIX awk,G=gawk

V 变量 含义 缺省值
——————————————————–
N ARGC 命令行参数个数
G ARGIND 当前被处理文件的ARGV标志符
N ARGV 命令行参数数组
G CONVFMT 数字转换格式 %.6g
P ENVIRON UNIX环境变量
N ERRNO UNIX系统错误消息
G FIELDWIDTHS 输入字段宽度的空白分隔字符串
A FILENAME 当前输入文件的名字
P FNR 当前记录数
A FS 输入字段分隔符 空格
G IGNORECASE 控制大小写敏感0（大小写敏感）
A NF 当前记录中的字段个数
A NR 已经读出的记录数
A OFMT 数字的输出格式 %.6g
A OFS 输出字段分隔符 空格
A ORS 输出的记录分隔符 新行
A RS 输入的记录他隔符 新行
N RSTART 被匹配函数匹配的字符串首
N RLENGTH 被匹配函数匹配的字符串长度
N SUBSEP 下标分隔符 “34″

6.awk的内置函数

V 函数 用途或返回值
————————————————
N gsub(reg,string,target) 每次常规表达式reg匹配时替换target中的string
N index(search,string) 返回string中search串的位置
A length(string) 求串string中的字符个数
N match(string,reg) 返回常规表达式reg匹配的string中的位置
N printf(format,variable) 格式化输出，按format提供的格式输出变量variable。
N split(string,store,delim) 根据分界符delim,分解string为store的数组元素
N sprintf(format,variable) 返回一个包含基于format的格式化数据，variables是要放到串中的数据
G strftime(format,timestamp) 返回一个基于format的日期或者时间串，timestmp是systime()函数返回的时间
N sub(reg,string,target) 第一次当常规表达式reg匹配，替换target串中的字符串
A substr(string,position,len) 返回一个以position开始len个字符的子串
P totower(string) 返回string中对应的小写字符
P toupper(string) 返回string中对应的大写字符
A atan(x,y) x的余切(弧度)
N cos(x) x的余弦(弧度)
A exp(x) e的x幂
A int(x) x的整数部分
A log(x) x的自然对数值
N rand() 0-1之间的随机数
N sin(x) x的正弦(弧度)
A sqrt(x) x的平方根
A srand(x) 初始化随机数发生器。如果忽略x，则使用system()
G system() 返回自1970年1月1日以来经过的时间（按秒计算）

这组命令在搜索与定位文件中特定的主题方面非常有用。要搜索的模式可以被认为是一些关键词，您可以用它们来搜索文件中包含的这些关键词。编写程序时，可以用它来寻找某一个函数，或是相关的词组。grep 命令的搜索功能比 fgrep 强大，因为 grep 命令的搜索模式可以是正则表达式，而 fgrep 却不能。

该组命令中的每一个命令都有一组选项，利用这些选项可以改变其输出方式。例如，可以在搜索到的文本行上加入行号，或者只输出文本行的行号，或者输出所有与搜索模式不匹配的文本行，或只简单地输出已搜索到指定模式的文件名，并且可以指定在查找模式时忽略大小写。

这组命令在指定氖淙胛募胁檎矣肽Ｊ狡ヅ涞男小Ｈ绻挥兄付ㄎ募虼颖曜际淙?中读取。正常情况下，每个匹配的行被显示到标准输出。如果要查找的文件是多个，则在每一行输出之前加上文件名。

语法：  grep [选项] [查找模式] [文件名1，文件名2，……]  egrep [选项] [查找模式] [文件名1，文件名2，……]  fgrep [选项] [查找模式] [文件名1，文件名2，……]

该命令的各选项含义如下：

-E 每个模式作为一个扩展的正则表达式对待。 -F 每个模式作为一组固定字符串对待（以新行分隔），而不作为正则表达式。 -b 在输出的每一行前显示包含匹配字符串的行在文件中的字节偏移量。 -c 只显示匹配行的数量。 -i 比较时不区分大小写。 -h 在查找多个文件时，指示grep不要将文件名加入到输出之前。 -l 显示首次匹配串所在的文件名并用换行符将其隔开。    当在某文件中多次出现匹配串时，不重复显示此文件名。 -n 在输出前加上匹配串所在行的行号（文件首行行号为1）。 -v 只显示不包含匹配串的行。 -x 只显示整行严格匹配的行。 -e expression 指定检索使用的模式。用于防止以“-”开头的模式被解释为命令选项。 -f expfile 从expfile文件中获取要搜索的模式，一个模式占一行。

对该组命令的使用还需注意以下方面：

在命令后键入搜索的模式，再键入要搜索的文件。其中，文件名列表中也可以使用特殊字符，如 “*” 等，用来生成文件名列表。如果想在搜索的模式中包含有空格的字符串，可以用单引号把要搜索的模式括起来，用来表明搜索的模式是由包含空格的字符串组成。否则，Shell 将把空格认为是命令行参数的定界符，而 grep 命令将把搜索模式中的单词解释为文件名列表中的一部分。在下面的例子中，grep 命令在文件 example 中搜索模式 “text file”。

grep ’text file’ example

用户可以在命令行上用Shell特殊字符来生成将要搜索的文件名列表。在下面的例子中，特殊字符“*”用来生成一个文件名列表，该列表包含当前目录下所有的文件。该命令将搜索出当前目录下所有文件中与模式匹配的行。

grep data *

特殊字符在搜索一组指定的文件时非常有用。例如，如果想搜索所有的C程序源文件中特定的模式，您可以用“*.c”来指定文件名列表。假设用户的 C程序中包含一些不必要的转向语句（goto语句），想要找到这些语句，可以用如下的命令来搜索并显示所有包含 goto语句的代码行：

grep goto *.c

用户可以在命令行上键入搜索模式，也可以使用 -f 选项从指定文件中读取要搜索的模式。在文件中，每个搜索模式占一行。如果经常要搜索一组常见字符串时，这个功能非常有用。在下面的例子中，用户要在文件 exam 中搜索字符串 “editor” 和 “create”，就把要搜索的模式放置在文件 mypats 中，然后，grep 命令从文件 mypats 中读取要搜索的模式。

grep -f mypats exam

• 当把awk代码存储到文件中的时候，’是不需要的，即开头和末尾均不需要’。
• 一下为参考链接：
• http://fanqiang.chinaunix.net/program/shell/2005-03-30/3068.shtml
• http://fanqiang.chinaunix.net/program/shell/index.shtml
• http://www.linuxsir.org/bbs/showthread.php?t=184399

GAWK

第一章 前言
第二章 简介
第三章 读取输入档案
第四章 印出
第五章 Patterns
第六章 算式(Expression)作为Actions的叙述
第七章 Actions里面的控制叙述
第八章 内建函式(Built-in Functions)
第九章 使用者定义的函式
第十章 □例
第十一章 结论
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

第一章 前言

awk 是一个程式语言，对於资料的处理具有很强的功能。对於文
字档里的资料做修改、比对、抽取等的处理，awk 能够以很短的程式
轻易地完成。如果使用 C 或 Pascal 等语言写程式完成上述的动作，
会不方便且很花费时间，所写的程式也会很大。

awk 能够依照使用者的定义格式来分解输入资料，也可依照使用
者定义的格式来印出资料。

awk 名称的由来是由它的原始设计者的姓氏之第一个字母而命名
：Alfred V. Aho, Peter J. Weinberger, Brian W. Kernighan。
awk最初在1977年完成。一个新版本的awk在1985年被发表，它的功能
比旧版本增强不少。

gawk 是GNU所做的 awk，gawk 最初在1986年完成，之後不断地
被改进、更新。gawk 包含 awk 的所有功能。

往後的 gawk 将以下面的2个输入档案来做例子说明。

档案’BBS-list’：
aardvark 555-5553 1200/300 B
alpo-net 555-3412 2400/1200/300 A
barfly 555-7685 1200/300 A
bites 555-1675 2400/1200/300 A
camelot 555-0542 300 C
core 555-2912 1200/300 C
fooey 555-1234 2400/1200/300 B
foot 555-6699 1200/300 B
macfoo 555-6480 1200/300 A
sdace 555-3430 2400/1200/300 A
sabafoo 555-2127 1200/300 C

档案’shipped’：
Jan 13 25 15 115
Feb 15 32 24 226
Mar 15 24 34 228
Apr 31 52 63 420
May 16 34 29 208
Jun 31 42 75 492
Jul 24 34 67 436
Aug 15 34 47 316
Sep 13 55 37 277
Oct 29 54 68 525
Nov 20 87 82 577
Dec 17 35 61 401

Jan 21 36 64 620
Feb 26 58 80 652
Mar 24 75 70 495
Apr 21 70 74 514
第二章 简介

gawk 的主要功能是针对档案的每一行(line)搜寻指定的 patterns
。当一行里有符合指定的 patterns，gawk 就会在此一行执行被指定
的 actions。 gawk 依此方式处理输入档案的每一行直到输入档案结
束。

gawk 程式是由很多的 pattern 与 action 所组成，action 写在
大括号 { } 里面，一个pattern後面就跟著一个action。整个 gawk 程
式会像下面的样子：

pattern {action}
pattern {action}

在 gawk 程式里面的规则，pattern 或 action 能够被省略，但
是两个不能同时被省略。如果 pattern 被省略，对於输入档里面的
每一行，action 都会被执行。如果 action 被省略，内定的 action
则会印出所有符合 pattern 的输入行。
2.1 如何执行gawk程式

基本上，有2个方法可以执行gawk程式。

□如果 gawk 程式很短，则 gawk 可以直接写在 command line，如下所示：

gawk ‘program’ input-file1 input-file2 …

其中 program 包括一些 pattern 和 action。

□如果 gawk 程式较长，较为方便的做法是将 gawk 程式存在一个档案，
即 patterns 与 actions 写在档名为 program-file 的档案里面，执行
gawk 的格式如下所示：

gawk -f program-file input-file1 input-file2 …

gawk 程式的档案不止一个时，执行gawk 的格式如下所示：

gawk -f program-file1 -f program-file2 … input-file1
input-file2 …
2.2 一个简单的例子

现在我们举一个简单的例子，因为 gawk 程式很短，所以将 gawk 程
式直接写在 command line。

gawk ‘/foo/ {print $0}’ BBS-list

实际的 gawk 程式为 /foo/ {print $0}。/foo/ 为 pattern，意思为搜
寻输入档里的每一行是否含有子字串 ‘foo’，如果含有 ‘foo’ 则执行 action。
action 为 print $0，是将现在这一行的内容印出。BBS-list 是输入的档案。

执行完上述指令後，会印出下面的结果：
fooey 555-1234 2400/1200/300 B
foot 555-6699 1200/300 B
macfoo 555-6480 1200/300 A
sabafoo 555-2127 1200/300 C
2.3 一个较复杂的例子

gawk ‘$1 == “Feb” {sum=$2+$3} END {print sum}’ shipped

现在这个例子会将输入档 ’shipped’ 的第一个栏位与 “Feb” 做比较
，如果相等，则其对应的第2栏位与第3栏位的值会被加到变数 sum。
对於输入档的每一行重复上述的动作，直到输入档的每一行都被处理
过为止。最後将 sum 的值印出。END {print sum} 的意思为在所有的输
入读完之後，执行一次 print sum 的动作，也就是把 sum 的值印出。

下面是执行的结果：
84
第三章 读取输入档案

gawk的输入可以从标准输入或指定的档案里读取。输入的读取单
位被称为”记录”(records)，gawk 在做处理时，是一个记录一个记
录地处理。每个记录的内定值是一行(line)，一个记录又被分为多个
栏位(fields)。
3.1 如何将输入分解成记录(records)

gawk 语言会把输入分解成记录(record)。记录与记录之间是以
record separator 隔开，record separator 的内定值是表示新一行的
字元(newline character)，因此内定的 record separator 使得文字
的每一行是一个记录。

record separator 随著内建变数 RS 的改变而改变。RS 是一个字串，
它的内定值是”\n”。仅有 RS 的第一个字元是有效的，它被当作 record
separator，而 RS 的其它字元会被忽略。

内建变数 FNR 会储存目前的输入档案已经被读取的记录之个数。内
建变数 NR 会储存目前为止所有的输入档案已经被读取的记录之个数。
3.2 栏位(field)

gawk 会自动将每个记录分解成多个栏位 (field)。类似於字在一
行里面，gawk 的内定动作会认为栏位之间是以 whitespace 分开。在
gawk 里，whitespace 的意思是一个或多个空白或 tabs。

在 gawk 程式里面，以’$1′表示第一个栏位，’$2′表示第二个栏位
，依此类推。举个例子，假设输入的一行如下所示：

This seems like a pretty nice example.

第一个栏位或 $1 是’This’，第二个栏位或 $2 是 ’seems’，依此类推。
有个地方值得特别注意，第七个栏位或 $7 是’example.’而非’example’。

不论有多少栏位，$NF 可用来表示一个记录的最後一个栏位。以
上面的例子为例，$NF 与 $7 相同，也就是’example.’。

NF 是一个内建变数，它的值表示目前这个记录之栏位的个数。

$0，看起来好像是第零个栏位，它是一个特例，它表示整个记录。

下面是一个较复杂的例子：

gawk ‘$1~/foo/ {print $0}’ BBS-list

结果如下：
fooey 555-1234 2400/1200/300 B
foot 555-6699 1200/300 B
macfoo 555-6480 1200/300 A
sabafoo 555-2127 1200/300 C

这个例子是把输入档’BBS-list’的每个记录的第一个栏位作检查，如
果它含有子字串’foo’，则这一个记录会被印出。
3.3 如何将记录分解成栏位

gawk 根据 field separator 将一个记录分解成栏位。field sepa-
rator 以内建变数 FS 表示。

举个例子，假如 field separator 是’oo’，则下面的行：

moo goo gai pan

会被分成三个栏位：’m'、’ g’、’ gai pan’。

在 gawk 程式里，可以使用’='来改变 FS 的值。例如:

gawk ‘BEGIN {FS=”,”}; {print $2}’

输入行如下：

John Q. Smith, 29 Oak St., Walamazoo, MI 42139

执行gawk的结果将印出字串 ‘ 29 Oak St.’。BEGIN 後面的 action 会在
第一个记录被读取之前执行一次。
第四章 印出

在gawk程式里，actions 最常做的事就是印出(printing)。简单
的印出，使用 printe叙述。复杂格式的印出，使用 printf 叙述。
4.1 print叙述

print 叙述用在简单、标准的输出格式。叙述的格式如下所示：

print item1, item2, …

输出时，各个 item 之间会以一个空白分开，最後会换行(newline)。

如果 ‘print’叙述之後没有跟著任何东西，它与’print $0′的效
果一样，它会印出现在的记录(record)。要印出空白行可使用’print
“”‘。 印出一段固定的文字，可用双引号将文字的两边括起来，例如
‘print “Hello there”‘。

这里是一个例子，它会把每个输入记录的前二个栏位印出：

gawk ‘{print $1,$2}’ shipped

结果如下所示：
Jan 13
Feb 15
Mar 15
Apr 31
May 16
Jun 31
Jul 24
Aug 15
Sep 13
Oct 29
Nov 20
Dec 17

Jan 21
Feb 26
Mar 24
Apr 21
4.2 Output Separators

前面我们已提过如果 print 叙述包含有多个 item，item 之间
用逗点分开，则印出时各个item会被一个空白隔开。你能够使用任何
的字串作为 output field separator，可以经由内建变数 OFS 的设
定来更改 output field separator。OFS 的初始值为” “，即一格的
空白。

整个 print 叙述的输出被称为 output record。print 叙述输
出 output record 之後，会接著输出一个字串，此字串称为 output
record separator。内建变数 ORS 用来指明此字串。ORS 的初始值
为 “\n”，也就是换行。

下面这个例子会印出每个记录的第一个栏位和第二个栏位，此二
个栏位之间以分号’;'分开，每行输出之後会加入一个空白行。

gawk ‘BEGIN {OFS=”;”; ORS=”\n\n”} {print $1, $2}’ BBS-list

结果如下所示：
aardvark;555-5553

alpo-net;555-3412

barfly;555-7685

bites;555-1675

camelot;555-0542

core;555-2912

fooey;555-1234

foot;555-6699

macfoo;555-6480

sdace;555-3430

sabafoo;555-2127

4.3 printf叙述

printf 叙述会使得输出格式较容易精确地控制。printf 叙述可以
指定每个 item 印出的宽度，也可以指定数字的各种型式。

printf 叙述的格式如下：

printf format, item1, item2, …

print 与 printf 的差别是在於 format, printf 的引数比 print
多了字串 format。format 的型式与 ANSI C 的 printf 之格式相同。

printf 并不会做自动换行的动作。内建变数 OFS 与 ORS 对 printf 叙
述没有任何影响。

格式的指定以字元’%'开始，後面接著格式控制字母。

格式控制字母如下所示：

‘c’ 将数字以 ASCII 字元印出。
例如’printf “%C”,65′会印出字元’A'。

‘d’ 印出十进位的整数。

‘i’ 印出十进位的整数。

‘e’ 将数字以科学符号的形式印出。
例如

print “$4.3e”,1950

结果会印出’1.950e+03′。

‘f’ 将数字以浮点的形式印出。

‘g’ 将数字以科学符号的形式或浮点的形式印出。数字的绝对值如果
大於等於0.0001则以浮点的形式印出，否则以科学符号的形式印
出。

‘o’ 印出无号的八进位整数。

’s’ 印出一个字串。

‘x’ 印出无号的十六进位整数。10至15以’a'至’f'表示。

‘X’ 印出无号的十六进位整数。10至15以’A'至’F”表示。

‘%’ 它并不是真正的格式控制字母，’%%”将印出”%’。

在 % 与格式控制字母之间可加入 modifier，modifier 是用来进一
步控制输出的格式。可能的 modifier 如下所示：

‘-’ 使用在 width 之前，指明是向左靠齐。如果’-'没有出现，则会在
被指定的宽度向右靠齐。例如：

printf “%-4S”, “foo”

会印出’foo ‘。

‘width’ 这一个数字指示相对应的栏位印出时的宽度。例如：

printf “%4s”,”foo”

会印出’ foo’。

width 的值是一个最小宽度而非最大宽度。如果一个 item 的
值需要的宽度比 width 大，则不受 width 的影响。例如

printf “%4s”,”foobar”

将印出’foobar’。

‘.prec’ 此数字指定印出时的精确度。它指定小数点右边的位数。如
果是要印出一个字串，它指定此字串最多会被印出多少个字
元。
第五章 patterns

在 gawk 程式里面，当 pattern 符合现在的输入记录(record)，其
相对应的 action 才会被执行。
5.1 Pattern的种类

这里对 gawk 的各种 pattern 型式作一整理：

/regular expression/
一个 regular expression 当作一个 pattern。每当输入记录 (
record)含有 regular expression 就视为符合。

expression
一个单一的 expression。当一个值不为 0 或一个字串不是空的，
则可视为符合。

pat1,pat2
一对的 patterns 以逗号分开，指定记录的□围。

BEGIN
END
这是特别的 pattern, gawk 在开始执行或要结束时会分别执行相
对应於BEGIN或END的 action。

null
这是一个空的pattern，对於每个输入记录皆视为符合pattern。
5.2 Regular Expressions当作Patterns

一个 regular expression 可简写为 regexp，是一种描述字串的方
法。一个 regular expression 以斜线(’/')包围当作 gawk 的 pattern。

如果输入记录含有 regexp 就视为符合。例如：pattern 为 /foo/，
对於任何输入记录含有’foo’则视为符合。

下面的例子会将含有’foo’的输入记录之第2个栏位印出。

gawk ‘/foo/ {print $2}’ BBS-list

结果如下：
555-1234
555-6699
555-6480
555-2127

regexp 也能使用在比较的算式。

exp ~ /regexp/
如果 exp 符合 regexp，则结果为真(true)。

exp !~ /regexp/
如果 exp 不符合 regexp，则结果为真。
5.3 比较的算式当作Patterns

比较的 pattern 用来测试两个数字或字串的关系诸如大於、等於
、小於。下面列出一些比较的pattern：

x x<=y 如果 x 小於、等於 y，则结果为真。
x>y 如果 x 大於 y，则结果为真。
x>=y 如果 x 大於、等於 y，则结果为真。
x==y 如果 x 等於 y，则结果为真。
x!=y 如果 x 不等於 y，则结果为真。
x~y 如果 x 符合 regular expression y，则结果为真。
x!~y 如果 x 不符合 regular expression y，则结果为真。

上面所提到的 x 与 y，如果二者皆是数字则视为数字之间的比较，
否则它们会被转换成字串且以字串的形式做比较。两个字串的比较，
会先比较第一个字元，然後比较第二个字元，依此类推，直到有不同
的地方出现为止。如果两个字串在较短的一个结束之前是相等，则视
为长的字串比短的字串大。例如 “10″ 比 “9″ 小，”abc” 比 “abcd” 小。
5.4 使用布林运算的Patterns

一个布林(boolean) pattern 是使用布林运算”或”(’||’)，”及”
(’&&’)，”反”(’!')来组合其它的pattern。
例如：

gawk ‘/2400/ && /foo/’ BBS-list
gawk ‘/2400/ || /foo/’ BBS-list
gawk ‘! /foo/’ BBS-list
第六章 算式(Expression)作为Actions的叙述

算式(Expression) 是gawk程式里面action的基本构成者。
6.1 算术运算

gawk 里的算术运算如下所示：

x+y 加
x-y 减
-x 负
+x 正。实际上没有任何影响。
x*y 乘
x/y 除
x%y 求馀数。例如 5%3=2。
x^y
x**y x 的 y 次方。例如2^3=8。
6.2 比较算式与布林算式

比较算式 (comparison expression) 用来比较字串或数字的关系
，运算符号与 C 语言相同。表列如下：

x x<=y
x>y
x>=y
x==y
x!=y
x~y
x!~y

比较的结果为真(true)则其值是 1。否则其值是 0。

布林算式(boolean expression)有下面三种：

boolean1 && boolean2
boolean1 || boolean2
! boolean
6.3 条件算式(Conditional Expressions)

一个条件式算式是一种特别的算式，它含有3个运算元。
条件式算式与C语言的相同：

selector ? if-true-exp : if-false-exp

它有3个子算式。第一个子算式selector 首先会被计算。如果是真,
则if-true-exp会被计算且它的值变成整个算式的值。否则if-false-
exp 会被计算且它的值变成整个算式的值。

例如下面的例子会产生x的绝对值：

x>0 ? x : -x
第七章 Actions里面的控制叙述

在 gawk 程式里面，控制叙述诸如 if、while 等控制程式执行的流
程。在 gawk 里的控制叙述与 C 的类似。

很多的控制叙述会包括其它的叙述，被包括的叙述称为 body。假
如 body 里面包括一个以上的叙述，必须以大括弧 { } 将这些叙述括起
来，而各个叙述之间需以换行(newline)或分号隔开。
7.1 if 叙述

if (condition) then-body [else else-body]

如果 condition 为真(true)，则执行 then-body，否则执行 else-body。

举一个例子如下：

if (x % 2 == 0)
print “x is even”
else
print “x is odd”
7.2 while 叙述

while (condition)
body

while 叙述做的第一件事就是测试 condition。假如 condition 为真则
执行 body 的叙述。body 的叙述执行完後，会再测试 condition，假如
condition 为真，则 body 会再度被执行。这个过程会一直被重复直到
condition 不再是真。如果 condition 第一次测试就是伪(false)，则
body 从没有被执行。

下面的例子会印出每个输入记录(record)的前三个栏位。

gawk ‘{ i=1
while (i <= 3) {
print $i
i++
}
}'
7.3 do-while 叙述

do
body
while (condition)

这个 do loop 执行 body 一次，然後只要 condition 是真则会重复执行 body。
即使开始时 condition 是伪，body 也会被执行一次。

下面的例子会印出每个输入记录十次。

gawk '{ i= 1
do {
print $0
i++
} while (i <= 10)
}'
7.4 for 叙述

for (initialization; condition; increment)
body

此叙述开始时会执行initialization，然後只要 condition是真，它
会重复执行body与做increment 。

下面的例子会印出每个输入记录的前三个栏位。

gawk '{ for (i=1; i<=3; i++)
print $i
}'
7.5 break 叙述

break 叙述会跳出包含它的 for、while、do-while 回圈的最内层。

下面的例子会找出任何整数的最小除数，它也会判断是否为质数。

gawk '# find smallest divisor of num
{ num=$1
for (div=2; div*div <=num; div++)
if (num % div == 0)
break
if (num % div == 0)
printf "Smallest divisor of %d is %d\n", num, div
else
printf "%d is prime\n", num }'
7.6 continue 叙述

continue 叙述使用於 for、while、do-while 回圈内部，它会跳
过回圈 body 的剩馀部分，使得它立刻进行下一次回圈的执行。

下面的例子会印出 0 至 20 的全部数字，但是 5 并不会被印出。

gawk 'BEGIN {
for (x=0; x<=20; x++) {
if (x==5)
continue
printf ("%d",x)
}
print ""
}'
7.7 next 叙述、next file 叙述、exit 叙述

next 叙述强迫 gawk 立刻停止处理目前的记录(record)而继续下一
个记录。

next file 叙述类似 next。然而，它强迫 gawk 立刻停止处理目前
的资料档。

exit 叙述会使得 gawk 程式停止执行而跳出。然而，如果 END 出现
，它会去执行 END 的 actions。
第八章 内建函式(Built-in Functions)

内建函式是 gawk 内建的函式，可在 gawk 程式的任何地方呼叫内建
函式。
8.1 数值方面的内建函式

int(x) 求出 x 的整数部份，朝向 0 的方向做舍去。例如：int(3.9)
是 3，int(-3.9) 是 -3。
sqrt(x) 求出 x 正的平方根值。例 sqrt(4)=2
exp(x) 求出 x 的次方。例 exp(2) 即是求 e*e 。
log(x) 求出 x 的自然对数。
sin(x) 求出 x 的 sine 值，x 是弪度量。
cos(x) 求出 x 的 cosine 值，x 是弪度量。
atan2(y,x) 求 y/x 的 arctangent 值，所求出的值其单位是弪度量。
rand() 得出一个乱数值。此乱数值平均分布在 0 和 1 之间。这个
值不会是 0，也不会是 1。
每次执行 gawk，rand 开始产生数字从相同点或 seed。
srand(x) 设定产生乱数的开始点或 seed 为 x。如果在第二次你设
定相同的 seed 值，你将再度得到相同序列的乱数值。
如果省略引数 x，例如 srand()，则现在的日期、时间会
被当成 seed。这个方法可使得乱数值是真正不可预测的。
srand 的传回值(return value)是前次所设定的 seed 值。
8.2 字串方面的内建函式

index(in, find)
它会在字串 in 里面，寻找字串 find 第一次出现的地方，传回值是
字串 find 出现在字串 in 里面的位置。如果在字串 in 里面找不到字
串 find，则传回值为 0。
例如：
print index("peanut","an")
会印出 3。

length(string)
求出 string 有几个字元。
例如：
length("abcde")
是 5。

match(string,regexp)
match 函式会在字串 string 里面，寻找符合 regexp 的最长、最靠
左边的子字串。传回值是 regexp 在 string 的开始位置，即 index
值。
match 函式会设定内在变数 RSTART 等於 index，它也会设定内在变
数 RLENGTH 等於符合的字元个数。如果不符合，则会设定 RSTART 为
0、RLENGTH 为 -1。

sprintf(format,expression1,...)
举 printf 类似，但是 sprintf 并不印出，而是传回字串。
例如：
sprintf("pi = %.2f (approx.)',22/7)
传回的字串为"pi = 3.14 (approx.)"

sub(regexp, replacement,target)
在字串 target 里面，寻找符合 regexp 的最长、最靠左边的地方，
以字串 replacement 代替最左边的 regexp。
例如：
str = "water, water, everywhere"
sub(/at/, "ith",str)
结果字串str会变成
"wither, water, everywhere"

gsub(regexp, replacement, target)
gsub 与前面的 sub 类似。在字串 target 里面，寻找符合 regexp 的
所有地方，以字串 replacement 代替所有的 regexp。
例如：
str="water, water, everywhere"
gsub(/at/, "ith",str)
结果字串str会变成
'wither, wither, everywhere"

substr(string, start, length)
传回字串 string 的子字串，这个子字串的长度为 length 个字元，
从第 start 个位置开始。
例如：
substr("washington",5,3)
传回值为"ing"
如果 length 没有出现，则传回的子字串是从第 start 个位置开始
至结束。
例如：
substr("washington",5)
传回值为"ington"

tolower(string)
将字串string的大写字母改为小写字母。
例如：
tolower("MiXeD cAsE 123")
传回值为"mixed case 123"

toupper(string)
将字串string的小写字母改为大写字母。
例如：
toupper("MiXeD cAsE 123")
传回值为"MIXED CASE 123"
8.3 输入输出的内建函式

close(filename)
将输入或输出的档案 filename 关闭。

system(command)
此函式允许使用者执行作业系统的指令，执行完毕後将回到 gawk
程式。
例如：
BEGIN {system("ls")}
第九章 使用者定义的函式(User-defined Functions)

复杂的 gawk 程式常常可以使用自己定义的函式来简化。呼叫使用
者定义的函式与呼叫内建函式的方法一样。
9.1 函式定义的格式

函式的定义可以放在 gawk 程式的任何地方。

一个使用者定义的函式其格式如下：

function name (parameter-list) {
body-of-function
}

name 是所定义的函式之名称。一个正确的函式名称可包括一序列的字
母、数字、下标线 (underscores)，但是不可用数字做开头。

parameter-list 是列出函式的全部引数(argument)，各个引数之
间以逗点隔开。

body-of-function 包含 gawk 的叙述 (statement)。它是函式定义
里最重要的部份，它决定函式实际要做何种事。
9.2 函式定义的例子

下面这个例子，会将每个记录的第一个栏位之值的平方与第二个
栏位之值的平方加起来。

{print "sum =",SquareSum($1,$2)}
function SquareSum(x,y) {
sum=x*x+y*y
return sum
}
第十章 □例

这里将列出 gawk 程式的一些例子。

gawk '{if (NF > max) max = NF}
END {print max}’
此程式会印出所有输入行之中，栏位的最大个数。

gawk ‘length($0) > 80′
此程式会印出一行超过 80 个字元的每一行。此处只有 pattern 被
列出，action 是采用内定的 print。

gawk ‘NF > 0′
对於拥有至少一个栏位的所有行，此程式皆会印出。这是一个简
单的方法，将一个档案里的所有空白行删除。

gawk ‘{if (NF > 0) print}’
对於拥有至少一个栏位的所有行，此程式皆会印出。这是一个简
单的方法，将一个档案里的所有空白行删除。

gawk ‘BEGIN {for (i = 1; i <= 7; i++)
print int(101 * rand())}'
此程式会印出□围是 0 到 100 之间的 7 个乱数值。

ls -l files | gawk '{x += $4}; END {print "total bytes: " x}'
此程式会印出所有指定的档案之bytes数目的总和。

expand file | gawk '{if (x < length()) x = length()}
END {print "maximum line length is " x}'
此程式会将指定档案里最长一行的长度印出。expand 会将 tab 改
成 space，所以是用实际的右边界来做长度的比较。

gawk 'BEGIN {FS = ":"}
{print $1 | "sort"}' /etc/passwd
此程式会将所有使用者的login名称，依照字母的顺序印出。

gawk '{nlines++}
END {print nlines}'
此程式会将一个档案的总行数印出。

gawk 'END {print NR}'
此程式也会将一个档案的总行数印出，但是计算行数的工作由gawk
来做。

gawk '{print NR,$0}'
此程式印出档案的内容时，会在每行的最前面印出行号，它的功
能与 'cat -n' 类似。
第十一章 结论

gawk 对於资料的处理具有很强的功能。它能够以很短的程式完成
想要做的事，甚至一或二行的程式就能完成指定的工作。同样的一件
工作，以 gawk 程式来写会比用其它程式语言来写短很多。

gawk 是 GNU 所做的 awk，它是公众软体(Public Domain) 可免费使
用。
(http://www.fanqiang.com)

原文链接：http://www.phpx.com/happy/top58375.html