亚洲欧美精品在线,欧美一级播放,99国产精品久久久久老师

c++ 学习 — Sat, 21 Aug 2010 14:28:00 GMT

Source Insight的强大的代码分析功能让所有windows下的众生受益菲浅�?/p>

而Source insight的�h格即使是面对Windows Vista也不逞多。嘿�ѝ��东西是好东�ѝ�?/p>

个�h认�ؓ它也对得赯��个�h根{��可惜没�c�뀂用不�v呀�?/p>

咋办呢。用vim�Q�cscope打造一个免费的吧�?br>

1安装cscope

cscope的编译和安装没有特别之处�Q?/configure - make - make install卛_��?br> 安�{完毕后先阅读说明: vi /usr/share/vim/vim63/doc/if_cscop.txt.gz
�|�上也有中文版本�Q�http://vcd.gro.clinux.org/doc/if_cscop.html
在vim中��用�ƈ不需要进行太多的讄��Q�不�q�首先vim�~�译时必��d��入了cscope的支�?br>
$ vim --version | grep cscope
+cryptv +cscope +dialog_con +diff +digraphs -dnd -ebcdic +emacs_tags +eval

嗯，我用的这个版本的vim是支持cscope的�?br>

�?照vim里cscope的参考手�?在vim中执�?:help cscope"命��o)�Q�把cscope功能加到.vimrc里后(需要你的vim在编译时选择�?--enable-cscope"选项�Q�否则你需要重�? �~�译vim)�Q�配�|�就��完成了。然后用下面的命令生成代码的�W�号索引文�g�Q?br>

cscope -Rbkq

�q�个命��o会生成三个文�Ӟ��cscope.out, cscope.in.out, cscope.po.out�?br> 其中cscope.out是基本的�W�号索引�Q�后两个文�g是��?-q"选项生成的，可以加快cscope的烦引速度�?br> 上面所用到的命令参敎ͼ�含义如下�Q?br>

-R: 在生成烦引文件时�Q�搜索子目录树中的代�?br> -b: 只生成烦引文�Ӟ��不进入cscope的界�?br> -k: 在生成烦引文件时�Q�不搜烦/usr/include目录
-q: 生成cscope.in.out和cscope.po.out文�g�Q�加快cscope的烦引速度

接下来，��可以在vim里读代码了�?br> �? �q�在使用�q�程中，发现无法扑ֈ�C++的类、函数定义、调用关�p�R��仔�l�阅��M��cscope的手册后发现�Q�原来cscope在��生烦引文件时�Q�只搜烦�c�d��? C, lex和yacc的文�?后缀名�ؓ.c, .h, .l, .y)�Q�C++的文件根本没有生成烦引。不�q�按照手册上的说明，cscope支持c++和Java语言的文件�?br> 于是按照cscope手册上提供的�Ҏ��Q�先产生一个文件列表，然后让cscope��个列表中的每个文仉��生成索引�?br> ��Z��方便使用�Q�编写了下面的脚本来更新cscope和ctags的烦引文�Ӟ��

#!/bin/sh

find . -name "*.h" -o -name "*.c" -o -name "*.cc" > cscope.files
cscope -bkq -i cscope.files
ctags -R

�q�个脚本�Q�首先��用find命��o�Q�查扑ֽ�前目录及子目录中所有后�~�名�ؓ".h", ".c"�?.cc"的文�Ӟ��q�把查找�l�果重定向到文�gcscope.files中�?br> 然后cscope�Ҏ��cscope.files中的所有文�Ӟ��生成�W�号索引文�g�?br> 最后一条命令��用ctags命��o�Q�生成一个tags文�g�Q�在vim中执�?:help tags"命��o查询它的用法。它可以和cscope一起��用�?br>
目前只能在unix�p�d��操作�pȝ��下��用cscope�Q�虽然也有windows版本的cscope�Q�不�q�还有很多bug。在Linux技术中坚站上看到有作者在win2000上成功运行了gvim + cscope�Q�详情可以参阅：
http://www.chinalinuxpub.com/bbs/showthread.php?t=30185

cscope的主��在�Q?a style="color: #0000ff;" target="_blank">http://cscope.sourceforge.net/

在vim的网站上�Q�有很多和cscope相关的插�Ӟ��可以��L��一下你有没有所感兴��的。搜索结果在�q�里�Q?br> 点这�?/u>

��Z��方便��C��用cscope�Q�我们还需要下载cscope的键盘映���设�|�，
�q�样���可以在gvim中简单地通过快捷键来使用 cscope�Q�而不必敲复杂的命令了。键盘映���可以从
�q�里下蝲�Q?a  >http://cscope.sourceforge.net/cscope_maps.vim

���下载到�?cscope_maps.vim

文�g:	cscope_maps.vim.tar.gz
大小:	2KB
下蝲:	下蝲


攑֜�gvim的插件目录里�Q�如 C:\Program Files\Vim\vimfiles\plugin 中。Linux用户可以攑֜� 
$HOME/.vim/plugin 中�?/pre>
↑
建立�W�号数据�?†
我们假设我们要阅�ȝ��代码攑֜� D:\src\myproject 下。然后打开命��o行，�q�入源代码所在的目录�Q?br>�?cscope 建立搜烦文�g列表。在命��o行中执行以下命��o�Q?/pre>
dir /s /b *.c *.h  > cscope.files
如果你的源代码是C++�Q�则可以��?cpp �{�扩展名也加入到上面的命令中�?/pre>
dir /s /b *.c *.h *cpp *.hpp  > cscope.files
如果是Linux用户�Q�则可以使用 find 命��o实现同样的功能：
find $(pwd) -name "*.[ch]"
然后执行以下命��o�Q?/pre>
cscope -b
执行�l�束后你可以在当前目录下发现 cscope.out 文�g�Q�这���是 cscope 建立的符��h��据库�?/pre>
上面�q�个命��o中，-b参数使得cscope不启动自带的用户界面�Q�而仅仅徏立符��h��据库�?/pre>
↑
���览源代�?†
使用 gvim 打开你的源代码目录中��L��一个C�E�序文�g。然后在gvim中执行如下命令：
:cscope add D:\src\myproject\cscope.out
�׃���?gvim 中可以��用命令羃写，因此上面的命令可以写成：
:cs a D:\src\myproject\cscope.out
�q�样���打开了刚刚徏立的�W�号数据库。通过下面的命令可以检查数据库�q�接的存在�?/pre>
:cscope show
该命令可以羃写�ؓ
:cs s
现在���光标移动到源代码中的某个函数名上，依次按下一下组合键�Q?/pre>
s
�E�等片刻之后你会在屏�q�下攄���到如下的字样*1�Q?/pre>
Cscope tag: display
    #    line  filename / context / line
    1     342  D:\src\myproject\src\global.h <>
              void display(void );
    2     616  D:\src\myproject\src\command.c <>
              display();
    3     138  D:\src\myproject\src\display.c <>
              display(void )
    4     385  D:\src\myproject\src\main.c <>
              display();
    5     652  D:\src\myproject\src\main.c <>
              display();
    6     663  D:\src\myproject\src\main.c <>
              display();
Enter nr or choice ( to abort):
�q�里昄���出的���是整个工程中��用到�?display �q�个标识�W�的位置。此时输�?4�Q�回车，
卛_��跌��{�?main.c �?385 行调�?display() 函数的地方进行浏览。浏览结束后�?或�?
可以回到跌��{前的位置�?/pre>
然后���光标移动到源代码某个函数名上，�q�速地依次安下面的�l�合键：
s
其中 �?Ctrl-2 卛_��输入。同��P��屏幕上出��C��一排结果，选择之后你会发现�Q?br>跌��{到的文�g���在水��^方向的新�H�口中打开�?/pre>
然后���光标移动到源代码某个函数名上，�q�速地依次安下面的�l�合键：
s
选择之后你会发现�Q�蟩转到的文件将在垂直方向的新窗口中打开�?/pre>
以上我们���单介�l�了cscope的��用方法，其中我们只用��C��一�?s 命��o�Q�即跟在 �?后面�?s 键�?br>同样�Q�我们可以��用以下的功能键实��C��同的跌��{功能�?/pre>
c: 查找该函数被调用的位�|?
d: 查找该函数调用了哪些函数 
e: 查找指定的正规表辑ּ� 
f: 查找指定的文�?
g: 查找指定标识�W�的定义位置 
i: 查找该文件在哪些地方被包�?
s: 查找指定标识�W�的使用位置 
t: 查找指定的文本字�W�串
↑
命��o行��用说�?†
除了上述通过快捷键映���的方式使用cscope之外�Q�也可以直接在gvim命��o行中使用cscope。这样就可以
随意定义查找字符�Ԍ��而不必局限于源代码中已有的标识符。命令格式如下：
:cscope find  <关键�?gt;
该命令可以羃写�ؓ
:cs f  <关键�?gt;
一个比较实用的技巧是使用cscope打开文�g。��用以下命令即可直接打开名�ؓdisplay.c的文�Ӟ��
而不必先切换到display.c所在的目录�?/pre>
:cs f f display.c
cscope也支持正规表辑ּ�。如果记不清某个函数的名�U�ͼ�可以用下面的方式来找到该函数的定义位�|��?/pre>
:cs f g .*SetConfiguration.*
↑
版权 †
Cscope虽然不是GPL版权�Q�但是Cscope是开放源码的自由软�g�Q���用Cscope无须支付��M��费用�?/pre>
↑
参�?†
Cscope官方主页, http://cscope.sourceforge.net/ 
The Vim/Cscope tutorial, http://cscope.sourceforge.net/cscope_vim_tutorial.html 
Cscope on Win32, http://iamphet.nm.ru/cscope/ 
Vim中关�?cscope 的帮助，使用 :help cscope 命��o查看


c++ 学习 2010-08-21 22:28 发表评论

c++ 学习 — Tue, 03 Aug 2010 09:27:00 GMT

2.用完成例�E�方式实现的重叠I/O模型
#include
#include

#define PORT 5150
#define MSGSIZE 1024

#pragma comment(lib, "ws2_32.lib")

typedef struct
{
WSAOVERLAPPED overlap;
WSABUF        Buffer;
char          szMessage[MSGSIZE];
DWORD         NumberOfBytesRecvd;
DWORD         Flags;
SOCKET        sClient;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

DWORD WINAPI WorkerThread(LPVOID);
void CALLBACK CompletionROUTINE(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);

SOCKET g_sNewClientConnection;
BOOL g_bNewConnectionArrived = FALSE;

int main()
{
WSADATA     wsaData;
SOCKET      sListen;
SOCKADDR_IN local, client;
DWORD       dwThreadId;
int         iaddrSize = sizeof(SOCKADDR_IN);

// Initialize Windows Socket library
WSAStartup(0x0202, &wsaData);

// Create listening socket
sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind
local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

// Listen
listen(sListen, 3);

// Create worker thread
CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

while (TRUE)
{
    // Accept a connection
    g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    g_bNewConnectionArrived = TRUE;
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
}
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

while (TRUE)
{
    if (g_bNewConnectionArrived)
    {
      // Launch an asynchronous operation for new arrived connection
      lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
        GetProcessHeap(),
        HEAP_ZERO_MEMORY,
        sizeof(PER_IO_OPERATION_DATA));
      lpPerIOData->Buffer.len = MSGSIZE;
      lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
      lpPerIOData->sClient = g_sNewClientConnection;

      WSARecv(lpPerIOData->sClient,
        &lpPerIOData->Buffer,
        1,
        &lpPerIOData->NumberOfBytesRecvd,
        &lpPerIOData->Flags,
        &lpPerIOData->overlap,
        CompletionROUTINE);

      g_bNewConnectionArrived = FALSE;
    }

SleepEx(1000, TRUE);
}
return 0;
}

void CALLBACK CompletionROUTINE(DWORD dwError,
                                DWORD cbTransferred,
                                LPWSAOVERLAPPED lpOverlapped,
                                DWORD dwFlags)
{
LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;

if (dwError != 0 || cbTransferred == 0)
{
    // Connection was closed by client
closesocket(lpPerIOData->sClient);
HeapFree(GetProcessHeap(), 0, lpPerIOData);
}
else
{
    lpPerIOData->szMessage[cbTransferred] = '\0';
    send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);

    // Launch another asynchronous operation
    memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;

    WSARecv(lpPerIOData->sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      CompletionROUTINE);
}
}

用完成例�E�来实现重叠I/O比用事�g通知��单得多。在�q�个模型中，�ȝ��E�只用不停的接受�q�接卛_��Q�辅助线�E�判断有没有新的客户端连接被建立�Q�如果有�Q�就为那个客��L��套接字激�z�M��个异步的WSARecv操作�Q�然后调用SleepEx使线�E�处于一�U�可警告的等待状态，以��得I/O完成后CompletionROUTINE可以被内核调用。如果辅助线�E�不调用SleepEx�Q�则内核在完成一�ơI/O操作后，无法调用完成例程�Q�因为完成例�E�的�q�行应该和当初激�z�WSARecv异步操作的代码在同一个线�E�之内）�?br style="line-height: normal; ">完成例程内的实现代码比较��单，它取出接收到的数据，然后��数据原��不动的发送给客户端，最后重新激�z�d��一个WSARecv异步操作。注意，在这里用��C��“��N��数据”。我们在调用WSARecv的时候，参数lpOverlapped实际上指向一个比它大得多的结构PER_IO_OPERATION_DATA�Q�这个结构除了WSAOVERLAPPED以外�Q�还被我们附加了�~�冲区的�l�构信息�Q�另外还包括客户端套接字�{�重要的信息。这��P��在完成例�E�中通过参数lpOverlapped拿到的不仅仅是WSAOVERLAPPED�l�构�Q�还有后边尾随的包含客户端套接字和接收数据缓冲区�{�重要信息。这��L��C语言技巧在我后面介�l�完成端口的时候还会��用到�?/p>

�?完成端口模型
“完成端口”模型是迄今�ؓ止最为复杂的一�U�I/O模型。然而，假若一个应用程序同旉��要管理�ؓ��C��多的套接字，那么采用�q�种模型�Q�往往可以辑ֈ�最佳的�pȝ��性能�Q�但不幸的是�Q�该模型只适用于Windows NT和Windows 2000操作�pȝ��。因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候，而且希望随着�pȝ��内安装的CPU数量的增多，应用�E�序的性能也可以线性提升，才应考虑采用“完成端口”模型。要��C��的一个基本准则是�Q�假如要为Windows NT或Windows 2000开发高性能的服务器应用�Q�同时希望�ؓ大量套接字I/O��h��提供服务�Q�Web服务器便是这斚w��的典型例子）�Q�那么I/O完成端口模型便是最佳选择�Q�（节选自《Windows�|�络�~�程》第八章�Q?br style="line-height: normal; ">完成端口模型是我最喜爱的一�U�模型。虽然其实现比较复杂�Q�其实我觉得它的实现比用事�g通知实现的重叠I/O��单多了）�Q�但其效率是惊�h的。我在T公司的时候曾�l�帮同事写过一个邮件服务器的性能��试�E�序�Q�用的就是完成端口模型。结果表明，完成端口模型在多�q�接�Q�成千上万）的情况下�Q�仅仅依靠一两个辅助�U�程�Q�就可以辑ֈ�非常高的吞吐量。下面我�q�是从代码说��P��
#include
#include

#define PORT 5150
#define MSGSIZE 1024

#pragma comment(lib, "ws2_32.lib")

typedef enum
{
RECV_POSTED
}OPERATION_TYPE;

typedef struct
{
WSAOVERLAPPED overlap;
WSABUF         Buffer;
char           szMessage[MSGSIZE];
DWORD          NumberOfBytesRecvd;
DWORD          Flags;
OPERATION_TYPE OperationType;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

DWORD WINAPI WorkerThread(LPVOID);

int main()
{
WSADATA                 wsaData;
SOCKET                  sListen, sClient;
SOCKADDR_IN             local, client;
DWORD                   i, dwThreadId;
int                     iaddrSize = sizeof(SOCKADDR_IN);
HANDLE                  CompletionPort = INVALID_HANDLE_VALUE;
SYSTEM_INFO             systeminfo;
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

// Initialize Windows Socket library
WSAStartup(0x0202, &wsaData);

// Create completion port
CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

// Create worker thread
GetSystemInfo(&systeminfo);
for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)
{
CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
}

// Create listening socket
sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind
local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

// Listen
listen(sListen, 3);

while (TRUE)
{
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Associate the newly arrived client socket with completion port
    CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);

    // Launch an asynchronous operation for new arrived connection
    lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
      GetProcessHeap(),
      HEAP_ZERO_MEMORY,
      sizeof(PER_IO_OPERATION_DATA));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
    lpPerIOData->OperationType = RECV_POSTED;
    WSARecv(sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      NULL);
}

PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL);
CloseHandle(CompletionPort);
closesocket(sListen);
WSACleanup();
return 0;
}

DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
{
HANDLE                  CompletionPort=(HANDLE)CompletionPortID;
DWORD                   dwBytesTransferred;
SOCKET                  sClient;
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

while (TRUE)
{
    GetQueuedCompletionStatus(
      CompletionPort,
      &dwBytesTransferred,
      &sClient,
      (LPOVERLAPPED *)&lpPerIOData,
      INFINITE);
    if (dwBytesTransferred == 0xFFFFFFFF)
    {
      return 0;
    }

    if (lpPerIOData->OperationType == RECV_POSTED)
    {
      if (dwBytesTransferred == 0)
      {
        // Connection was closed by client
        closesocket(sClient);
        HeapFree(GetProcessHeap(), 0, lpPerIOData);
      }
      else
      {
        lpPerIOData->szMessage[dwBytesTransferred] = '\0';
        send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0);

        // Launch another asynchronous operation for sClient
        memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
        lpPerIOData->Buffer.len = MSGSIZE;
        lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
        lpPerIOData->OperationType = RECV_POSTED;
        WSARecv(sClient,
          &lpPerIOData->Buffer,
          1,
          &lpPerIOData->NumberOfBytesRecvd,
          &lpPerIOData->Flags,
          &lpPerIOData->overlap,
          NULL);
      }
    }
}
return 0;
}

首先�Q�说说主�U�程�Q?br style="line-height: normal; ">1.创徏完成端口对象
2.创徏工作者线�E�（�q�里工作者线�E�的数量是按照CPU的个数来军_��的，�q�样可以辑ֈ�最��x��能�Q?br style="line-height: normal; ">3.创徏监听套接字，�l�定�Q�监听，然后�E�序�q�入循环
4.在��@环中�Q�我做了以下几�g事情�Q?br style="line-height: normal; ">(1).接受一个客��L��q�接
(2).��该客户端套接字与完成端口绑定到一�?�q�是调用CreateIoCompletionPort�Q�但�q�次的作用不�?�Q�注意，按道理来�Ԍ��此时传递给CreateIoCompletionPort的第三个参数应该是一个完成键�Q�一般来�Ԍ��E�序都是传递一个单句柄数据�l�构的地址�Q�该单句柄数据包含了和该客户端连接有关的信息�Q�由于我们只兛_��套接字句柄，所以直接将套接字句柄作为完成键传递；
(3).触发一个WSARecv异步调用�Q�这�ơ又用到�?#8220;��N��数据”�Q��接收数据所用的�~�冲区紧跟在WSAOVERLAPPED对象之后�Q�此外，�q�有操作�c�d��{�重要信息�?br style="line-height: normal; ">
在工作者线�E�的循环中，我们
1.调用GetQueuedCompletionStatus取得本次I/O的相关信息（例如套接字句柄、传送的字节数、单I/O数据�l�构的地址�{�等�Q?br style="line-height: normal; ">2.通过单I/O数据�l�构扑ֈ�接收数据�~�冲区，然后��数据原��不动的发送到客户�?br style="line-height: normal; ">3.再次触发一个WSARecv异步操作

�?五种I/O模型的比�?br style="line-height: normal; ">我会从以下几个方面来�q�行比较
*有无每线�E?4�q�接数限�?br style="line-height: normal; ">如果在选择模型中没有重新定义FD_SETSIZE宏，则每个fd_set默认可以装下64个SOCKET。同��L��Q�受MAXIMUM_WAIT_OBJECTS宏的影响�Q�事仉��择、用事�g通知实现的重叠I/O都有每线�E�最�?4�q�接数限制。如果连接数成千上万�Q�则必须对客��L��套接字进行分�l�，�q�样�Q�势必增加程序的复杂度�?br style="line-height: normal; ">相反�Q�异步选择、用完成例程实现的重叠I/O和完成端口不受此限制�?/p>

*�U�程�?br style="line-height: normal; ">除了异步选择以外�Q�其他模型至��需�?个线�E�。一个主�U�程和一个辅助线�E�。同��L��Q�如果连接数大于64�Q�则选择模型、事仉��择和用事�g通知实现的重叠I/O的线�E�数�q�要增加�?/p>

*实现的复杂度
我的个�h看法是，在实现难度上�Q�异步选择<选择<用完成例�E�实现的重叠I/O<事�g选择<完成端口<用事仉��知实现的重叠I/O

*性能
�׃��选择模型中每�ơ都要重设读集，在select函数�q�回后还要针�Ҏ��有套接字�q�行逐一��试�Q�我的感觉是效率比较差；完成端口和用完成例程实现的重叠I/O基本上不涉及全局数据�Q�效率应该是最高的�Q�而且在多处理器情形下完成端口�q�要高一些；事�g选择和用事�g通知实现的重叠I/O在实现机制上都是采用WSAWaitForMultipleEvents�Q�感觉效率差不多�Q�至于异步选择�Q�不好比较。所以我的结论是:选择<用事仉��知实现的重叠I/O<事�g选择<用完成例�E�实现的重叠I/O<完成端口

c++ 学习 2010-08-03 17:27 发表评论

c++ 学习 — Tue, 03 Aug 2010 09:26:00 GMT

摘要: 如果你想在Windows�q�_��上构建服务器应用�Q�那么I/O模型是你必须考虑的。Windows操作�pȝ��提供了选择�Q�Select�Q�、异步选择�Q�WSAAsyncSelect�Q�、事仉��择�Q�WSAEventSelect�Q�、重叠I/O�Q�Overlapped I/O�Q�和完成端口�Q�Completion Port)�׃��U�I/O模型。每一�U�模型均适用于一�U�特定的应用场景。程序员应该对自��q��应用需求非常明��，而且�l�合考虑... 阅读全文

c++ 学习 2010-08-03 17:26 发表评论

c++ 学习 — Tue, 03 Aug 2010 07:50:00 GMT

摘要: 本文��单介�l�了当前Windows支持的各�U�Socket I/O模型�Q�如果你发现其中存在什么错误请务必赐教。一�Q�select模型二：WSAAsyncSelect模型三：WSAEventSelect模型四：Overlapped I/O 事�g通知模型五：Overlapped I/O 完成例程模型六：IOCP模型老陈有一个在外地工作的女儿，不能�l�常回来�Q�老陈和她通过信�g联系。他们的信会被邮递员投递到他们�?.. 阅读全文

c++ 学习 2010-08-03 15:50 发表评论

shell 变量间接引用

c++ 学习 — Mon, 02 Aug 2010 08:46:00 GMT

�q�种使用间接引用的方法是一个小技�? 如果�W�二个变量更改了它的�? 那么�W�一个变�?/div>

必须被适当的解除引�?��像上边的例子一�?. �q�运的是, 在Bash版本2中引�?/div>

�?{!variable}形式使得使用间接引用更加直观�?

假设一个变量的值是�W�二个变量的名字. 那么我们如何从第一个变量中取得�W�二个变量的值呢? 比如,

如果a=letter_of_alphabet�q�且letter_of_alphabet=z, 那么我们能够通过引用变量a来获得z�? �q�确

实是可以做到�? 它被�U�Cؓ间接引用. 它��用eval var1=\$$var2�q�种不��^常的形式.

c++ 学习 2010-08-02 16:46 发表评论

c++ 学习 — Wed, 30 Jun 2010 14:15:00 GMT

正则表达式就是由一�p�d��Ҏ��字符�l�成的字�W�串, 其中每个�Ҏ��字符都被�U�Cؓ元字�W?/em>, �q�些元字�W?/em>�q�不表示为它们字面上的含�? 而会被解释�ؓ一些特定的含义. 具个例子, 比如引用�W�号, 可能��是表示某�h的演讲内�? 同上, 也可能表�C�Zؓ我们下面��要讲到的符��L��?含义. 正则表达式其实是由普通字�W�和元字�W�共同组成的集合, �q�个集合用来匚w��(或指�?模式.

一个正则表辑ּ�会包含下列一��Ҏ��多项:

一个字�W�集. �q�里所指的字符集只包含普通字�W? �q�些字符只表�C�它们的字面含义. 正则表达式的最��单�Ş式就�?em>�?/em>包含字符�? 而不包含元字�W?

�?/em>. �?/em>指定了正则表辑ּ�所要匹配的文本在文本行中所处的位置. 比如, ^, �?span class="TOKEN">$��是�?

修饰�W?/em>. 它们扩大或羃��?修改)了正则表辑ּ�匚w��文本的范�? 修饰�W�包含星�? 括号, 和反斜杠.

正则表达式最主要的目的就是用�?RE)文本搜烦与字�W�串操作. (译者注: 以下正则表达式也会被��U�CؓRE.) RE能够匚w��单个字符或者一个字�W�集 -- �? 一个字�W�串, 或者一个字�W�串的一部分.

星号 -- * -- 用来匚w��它前面字�W�的��L��多次, 包括0��?/em>.

"1133*"匚w��11 + 一个或多个3 + 也允许后边还有其他字�W?/em>: 113, 1133, 111312, �{�等.

�?-- . -- 用于匚w��L��一个字�W? 除了换行�W? [1]

"13." 匚w��13 + 臛_��一个�Q意字�W?包括�I�格): 1133, 11333, 但不能匹�?tt class="REPLACEABLE">13 (因�ؓ�~�少"."所能匹配的臛_��一个�Q意字�W?.

脱字�W�号 -- ^ -- 匚w��行首, 但是某些时候需要依赖上下文环境, 在RE�? 有时候也表示对一个字�W�集取反.

��元�W?-- $ -- 在RE中用来匹配行��?

"XXX$" 匚w��行尾�?em>XXX.

"^$" 匚w��I��.

中括�?-- [...] -- 在RE�? ��匹配中括号字符集中的某一个字�W?

"[xyz]" ��会匚w��字符x, y, �?tt class="REPLACEABLE">z.

"[c-n]" 匚w��字符c到字�W?tt class="REPLACEABLE">n之间的�Q意一个字�W?

"[B-Pk-y]" 匚w��?tt class="REPLACEABLE">B�?tt class="REPLACEABLE">P, 或者从k�?tt class="REPLACEABLE">y之间的�Q意一个字�W?

"[a-z0-9]" 匚w��L��写字母或数�?

"[^b-d]" ��会匚w��范围�?tt class="REPLACEABLE">b�?tt class="REPLACEABLE">d之外�?/em>��L��一个字�W? �q�就是��?span class="TOKEN">^对字�W�集取反的一个实�? (��好像在某些情况�? !所表达的含�?.

��多个中括号字符集组合��? 能够匚w��一般的单词或数�? "[Yy][Ee][Ss]"能够匚w��yes, Yes, YES, yEs, �{�等. "[0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9][0-9][0-9]" 可以匚w��C�保�?Social Security number).

反斜�?-- \ -- 用来转义某个�Ҏ��含义的字�W? �q�意味着, �q�个�Ҏ��字符��会被解释�ؓ字面含义.

"\$"��会被解释成字符"$", 而不是RE中匹配行��Ҏ��字符. �怼��? "\\"��会被解释�ؓ字符"\".

转义�?span class="QUOTE">"��括�? -- \<...\> -- 用于匚w��单词边界.

��括号必��被转义才含有特�D�的含义, 否则它就表示��括��L��字面含义.

"\" 完整匚w��单词"the", 不会匚w��"them", "there", "other", �{�等.

bash$ cat textfile
This is line 1, of which there is only one instance. This is the only instance of line 2. This is line 3, another line. This is line 4.

bash$ grep 'the' textfile
This is line 1, of which there is only one instance. This is the only instance of line 2. This is line 3, another line.

bash$ grep '\' textfile
This is the only instance of line 2.

要想��定一个RE能否正常工作, 唯一的办法就是测试它.

1 TEST FILE: tstfile # 不匹�?
2 # 不匹�?
3 Run grep "1133*" on this file. # 匚w��.
4 # 不匹�?
5 # 不匹�?
6 This line contains the number 113. # 匚w��.
7 This line contains the number 13. # 不匹�?
8 This line contains the number 133. # 不匹�?
9 This line contains the number 1133. # 匚w��.
10 This line contains the number 113312. # 匚w��.
11 This line contains the number 1112. # 不匹�?
12 This line contains the number 113312312. # 匚w��.
13 This line contains no numbers at all. # 不匹�?

bash$ grep "1133*" tstfile
Run grep "1133*" on this file. # 匚w��. This line contains the number 113. # 匚w��. This line contains the number 1133. # 匚w��. This line contains the number 113312. # 匚w��. This line contains the number 113312312. # 匚w��.

扩展的正则表辑ּ�. ��d��了一些额外的匚w��字符到基本集合中. 用于egrep, awk, �?a >Perl.

问号 -- ? -- 匚w��它前面的字符, 但是只能匚w��1�ơ或0��? 通常用来匚w��单个字符.

加号 -- + -- 匚w��它前面的字符, 能够匚w��一�ơ或多次. 与前面讲�?span class="TOKEN">*号作用类�? 但是不能匚w��0个字�W�的情况.

1 # GNU版本的sed和awk能够使用"+",
2 # 但是它需要被转义一�?
3
4 echo a111b | sed -ne '/a1\+b/p'
5 echo a111b | grep 'a1\+b'
6 echo a111b | gawk '/a1+b/'
7 # 上边3句的作用相同.
8
9 # 感谢, S.C.

转义"大括�? -- \{ \} -- 在�{义后的大括号中加上一个数�? �q�个数字��是它前面的RE所能匹配的�ơ数.

大括号必��ȝ��q��{�? 否则, 大括号仅仅表�C�字面含�? �q�种用法�q�不是基本RE集合中的一部分, 仅仅是个技巧而以.

"[0-9]\{5\}" �_��匚w��5个数�?(所匚w��的字�W�范围是0�?).

使用大括号�Ş式的RE是不能够�?span class="QUOTE">"�l�典"(非POSIX兼容)�?a >awk版本中正常运行的. 然�? gawk命��o中有一�?code class="OPTION">--re-interval选项, 使用�q�个选项��允�怋�用大括号形式的RE�?无需转义).

bash$ echo 2222 | gawk --re-interval '/2{3}/'
2222

Perl与某些版本的egrep不需要�{义大括号.

圆括�?-- ( ) -- 括�v一�l�正则表辑ּ�. 当你想��?a >expr�q�行子字�W�串提取(substring extraction)的时�? 圆括号就有用�? 如果和下面要讲的"|"操作�W�结合��? 也非常有�?

竖线 -- | -- ��是RE中的"�?操作�W? 使用它能够匹配一�l�可选字�W�中的�Q意一�?

bash$ egrep 're(a|e)d' misc.txt
People who read seem to be better informed than those who do not. The clarinet produces sound by the vibration of its reed.

与GNU工具一�? 某些版本�?strong class="COMMAND">sed, ed, �?strong class="COMMAND">ex一栯��够支持扩展正则表辑ּ�, 上边�q�部分就描述了扩展正则表辑ּ�.

POSIX字符�c? [:class:]

�q�是另外一�U? 用于指定匚w��字符范围的方�?

[:alnum:] 匚w��字母和数�? �{��h�?kbd class="USERINPUT">A-Za-z0-9.

[:alpha:] 匚w��字母. �{��h�?kbd class="USERINPUT">A-Za-z.

[:blank:] 匚w��一个空格或是一个制表符(tab).

[:cntrl:] 匚w��控制字符.

[:digit:] 匚w��(十进�?数字. �{��h�?kbd class="USERINPUT">0-9.

[:graph:] (可打印的囑�Ş字符). 匚w��ASCII码��D��围在33 - 126之间的字�W? 与下面所提到�?kbd class="USERINPUT">[:print:]�c�M��, 但是不包括空格字�W?�I�格字符的ASCII码是32).

[:lower:] 匚w��写字母. �{��h�?kbd class="USERINPUT">a-z.

[:print:] (可打印的囑�Ş字符). 匚w��ASCII码��D��围在32 - 126之间的字�W? 与上边的[:graph:]�c�M��, 但是包含�I�格.

[:space:] 匚w��I�白字符(�I�格和水�q�_��表符).

[:upper:] 匚w��大写字母. �{��h�?kbd class="USERINPUT">A-Z.

[:xdigit:] 匚w��16�q�制数字. �{��h�?kbd class="USERINPUT">0-9A-Fa-f.

POSIX字符�c�通常都要用引��h��双中括号([[ ]])引�v�?

bash$ grep [[:digit:]] test.file
abc=723

如果在一个受限的范围�? �q�些字符�cȝ��臛_��以用�?a >通配(globbing)�?

bash$ ls -l ?[[:digit:]][[:digit:]]?
-rw-rw-r-- 1 bozo bozo 0 Aug 21 14:47 a33b

如果想了解POSIX字符�c�d��脚本中的使用情况, 请参�?a >例子 12-18�?a >例子 12-19.

Sed, awk, �?a >Perl在脚本中一般都被用作过滤器, �q�些�q��o器将会以RE为参�? �Ҏ��件或者I/O��进�?�q��o"或�{�? 请参�?a >例子 A-12�?a >例子 A-17, 来详�l�了解这�U�用�?

对于RE�q�个复杂的主�? 标准的参考材料是Friedl�?em class="CITETITLE">Mastering Regular Expressions. 由Dougherty和Robbins所�~�写�?em class="CITETITLE">Sed & Awk�q�本�? 也对RE�q�行了清晰的��. 如果惌��得这些书的更多信�? 请察�?a >参考文�?/em>.

注意事项

[1]
因�ؓsed, awk, �?a >grep通常用于处理单行, 但是不能匚w��一个换行符. 如果你想处理多行输入的话, 那么你可以��?�?来匹配换行符.

1 #!/bin/bash
2
3 sed -e 'N;s/.*/[&]/' << EOF # Here Document
4 line1
5 line2
6 EOF
7 # 输出:
8 # [line1
9 # line2]
10
11
12
13 echo
14
15 awk '{ $0=$1 "\n" $2; if (/line.1/) {print}}' << EOF
16 line 1
17 line 2
18 EOF
19 # 输出:
20 # line
21 # 1
22
23
24 # 感谢, S.C.
25
26 exit 0

c++ 学习 2010-06-30 22:15 发表评论

c++ 学习 — Mon, 28 Jun 2010 09:03:00 GMT

1.       expr expression

expr只能用于一元操作符,不支持二元操作符

1 x=1

2 x=$(expr $x + 1)

$x + 1之间必须有空�?/span>

2.       let expression

let 的��用方�?/span>

x=10

let x=$x+1

let x+=1

let x*=10

�{?/span>

Let没有�q�回�?/span>

3.       使用$((expression ))�?/span>((expression))形式

((expression))的��用方�?/span>

x=10

((x+=10))

(( expression)) 用法�?/span>let�c�M��

$(())的��用用�?/span>

�Q?/span> $((x=$x+10))

echo $x

y=$((x=$x-10))

echo $y

y=$(($x+1))

echo $y

echo $x

4.       使用$[ ]形式

例如�Q?/span>

n=1

: $[ n=$n+1 ](�Q�和$之间有空�?/span>)

y=$[ n = $n + 1 ]

echo $y

y=$[ $n+1 ]

echo $y

5.       使用decalare

例子�Q?/span>

decare –i num

num=$num+1

echo $num

c++ 学习 2010-06-28 17:03 发表评论

c++ 学习 — Sun, 27 Jun 2010 09:15:00 GMT

Bash Process Substitution
May 22, 2008 By Mitch Frazier
in
HOW-TOs
In addition to the fairly common forms of input/output redirection the shell recognizes something called process substitution. Although not documented as a form of input/output redirection, its syntax and its effects are similar.
The syntax for process substitution is:
<(list) or >(list)
where each list is a command or a pipeline of commands. The effect of process substitution is to make each list act like a file. This is done by giving the list a name in the file system and then substituting that name in the command line. The list is given a name either by connecting the list to named pipe or by using a file in /dev/fd (if supported by the O/S). By doing this, the command simply sees a file name and is unaware that its reading from or writing to a command pipeline.

To substitute a command pipeline for an input file the syntax is:
command ... <(list) ...
To substitute a command pipeline for an output file the syntax is:
command ... >(list) ...

At first process substitution may seem rather pointless, for example you might imagine something simple like:
uniq <(sort a)
to sort a file and then find the unique lines in it, but this is more commonly (and more conveniently) written as:
sort a | uniq
The power of process substitution comes when you have multiple command pipelines that you want to connect to a single command.

For example, given the two files:
# cat a e d c b a # cat b g f e d c b
To view the lines unique to each of these two unsorted files you might do something like this:
# sort a | uniq >tmp1 # sort b | uniq >tmp2 # comm -3 tmp1 tmp2 a f g # rm tmp1 tmp2
With process substitution we can do all this with one line:
# comm -3 <(sort a | uniq) <(sort b | uniq) a f g

Depending on your shell settings you may get an error message similar to:
syntax error near unexpected token `('
when you try to use process substitution, particularly if you try to use it within a shell script. Process substitution is not a POSIX compliant feature and so it may have to be enabled via:
set +o posix
Be careful not to try something like:
if [[ $use_process_substitution -eq 1 ]]; then set +o posix comm -3 <(sort a | uniq) <(sort b | uniq) fi
The command set +o posix enables not only the execution of process substitution but the recognition of the syntax. So, in the example above the shell tries to parse the process substitution syntax before the "set" command is executed and therefore still sees the process substitution syntax as illegal.

Of course, note that all shells may not support process substitution, these examples will work with bash.

�q�程替换与命令替换很�怼�. 命��o替换把一个命令的�l�果赋值给一个变�? 比如dir_contents=`ls -
al`或xref=$( grep word datafile). �q�程替换把一个进�E�的输出提供�l�另一个进�E?换句话说, 它把
一个命令的�l�果发给了另一个命�?.
命��o替换的模�?/p>
用圆括号扩�v来的命��o
>(command)
<(command)
启动�q�程替换. 它��?dev/fd/文�g��圆括号中的�q�程处理�l�果发送给另一个进�E? [1] (�?/p>
者注: 实际上现代的UNIX�c�L��作系�l�提供的/dev/fd/n文�g是与文�g描述�W�相关的, 整数n指的��?/p>
是进�E�运行时对应数字的文件描�q�符)
�?<"�?>"与圆括号之间是没有空格的. 如果加了�I�格, 会��生错�?
bash$ echo >(true)
/dev/fd/63
bash$ echo <(true)
/dev/fd/63
Bash在两个文件描�q�符之间创徏了一个管�? --fIn和fOut--. true命��o的stdin被连接到fOut
(dup2(fOut, 0)), 然后Bash�?dev/fd/fIn作�ؓ参数传给echo. 如果�pȝ��~�Z��/dev/fd/文�g, Bash�?/p>
使用临时文�g. (感谢, S.C.)
�q�程替换可以比较两个不同命��o的输�? 甚至能够比较同一个命令不同选项情况下的输出.
bash$ comm <(ls -l) <(ls -al)
total 12
-rw-rw-r-- 1 bozo bozo 78 Mar 10 12:58 File0
-rw-rw-r-- 1 bozo bozo 42 Mar 10 12:58 File2
-rw-rw-r-- 1 bozo bozo 103 Mar 10 12:58 t2.sh
total 20
drwxrwxrwx 2 bozo bozo 4096 Mar 10 18:10 .
drwx------ 72 bozo bozo 4096 Mar 10 17:58 ..
-rw-rw-r-- 1 bozo bozo 78 Mar 10 12:58 File0
-rw-rw-r-- 1 bozo bozo 42 Mar 10 12:58 File2
-rw-rw-r-- 1 bozo bozo 103 Mar 10 12:58 t2.sh
使用�q�程替换来比较两个不同目录的内容(可以查看哪些文�g名相�? 哪些文�g名不�?:
1 diff <(ls $first_directory) <(ls $second_directory)
一些进�E�替换的其他用法与技�?
1 cat <(ls -l)
2 # �{��h�?ls -l | cat
3
4 sort -k 9 <(ls -l /bin) <(ls -l /usr/bin) <(ls -l /usr/X11R6/bin)
5 # 列出�pȝ��3个主�?bin'目录中的所有文�? �q�且按文件名�q�行排序.
6 # 注意�?�?查一�? 上面��?个圆括号)明显不同的命令输��Z��递给'sort'.
7
8
9 diff <(command1) <(command2) # �l�出两个命��o输出的不同之�?
10
11 tar cf >(bzip2 -c > file.tar.bz2) $directory_name
12 # 调用"tar cf /dev/fd/?? $directory_name", �?bzip2 -c > file.tar.bz2".
13 #
14 # 因�ؓ/dev/fd/的系�l�属�?
15 # 所以两个命令之间的��道不必被命�?
16 #
17 # �q�种效果可以被模拟出�?
18 #
19 bzip2 -c < pipe > file.tar.bz2&
20 tar cf pipe $directory_name
21 rm pipe
22 # �?/p>
23 exec 3>&1
24 tar cf /dev/fd/4 $directory_name 4>&1 >&3 3>&- | bzip2 -c > file.tar.bz2 3>&-
25 exec 3>&-
26
27
28 # 感谢, Stephane Chazelas
一个读者给我发了一个有��的例子, 是关于进�E�替换的, 如下.
1 # 摘自SuSE发行版中的代码片�?
2
3 while read des what mask iface; do
4 # �q�里省略了一些命�?..
5 done < <(route -n)
6
7
8 # ��Z��试�? 我们让它做点�?
9 while read des what mask iface; do
10 echo $des $what $mask $iface
11 done < <(route -n)
12
13 # 输出:
14 # Kernel IP routing table
15 # Destination Gateway Genmask Flags Metric Ref Use Iface
16 # 127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo
17
18
19
20 # ��像Stephane Chazelas所�l�出的那�? 一个更�Ҏ��理解的等价代码是:
21 route -n |
22 while read des what mask iface; do # ��道的输��赋值给了变�?
23 echo $des $what $mask $iface
24 done # �q�将产生��Z��上边相同的输�?
25 # 然�? Ulrich Gayer指出 . . .
26 #+ �q�个��单的�{��h版本在while循环中��用了一个子shell,
27 #+ 因此当管道结束后, 变量��消�׃��.
28
29
30
31 # 更进一�? Filip Moritz解释了上面两个例子之间存在一个细微的不同之处,
32 #+ 如下所�C?
33
34 (
35 route -n | while read x; do ((y++)); done
36 echo $y # $y 仍然没有被声明或讄��
37
38 while read x; do ((y++)); done < <(route -n)
39 echo $y # $y 的��gؓroute -n的输��?
40 )
41
42 # 一般来�? (译者注: 原书作者在�q�里�q�未加注释符�?#", 应该是笔�?
43 (
44 : | x=x
45 # 看上��L��启动了一个子shell
46 : | ( x=x )
47 # �?/p>
48 x=x < <(:)
49 # 其实不是
50 )
51
52 # 当你要解析csv或类��g��西的时侯, �q�非常有�?
53 # 事实�? �q�就是SuSE的这个代码片断所要实现的功能.
注意事项
[1] �q�与命名��道(临时文�g)��h��相同的作�? �q�且, 事实�? 命名��道也被同时使用在进�E?/p>
替换�?

c++ 学习 2010-06-27 17:15 发表评论

关于bash的管道与�q�程的几个知识点

c++ 学习 — Fri, 25 Jun 2010 08:35:00 GMT

几个知识�?br style="word-wrap: break-word; line-height: normal; ">1.Bash在实现pipeline(��道|)时会发�v两个subshell(子shell)来运行|两边�?span href="tag.php?name=%C3%FC%C1%EE" class="t_tag" style="word-wrap: break-word; line-height: normal; cursor: pointer; border-bottom-width: 1px; border-bottom-style: solid; border-bottom-color: rgb(255, 0, 0); white-space: nowrap; ">命��o�Q�对�?span href="tag.php?name=%CF%B5%CD%B3" class="t_tag" style="word-wrap: break-word; line-height: normal; cursor: pointer; border-bottom-width: 1px; border-bottom-style: solid; border-bottom-color: rgb(255, 0, 0); white-space: nowrap; ">�pȝ��来说��是发�v两个childprocess(子进�E�）

2.fork是��生process的唯一途径�Q�exec*是执行程序的唯一途径

3.子进�E�会完全复制父进�E�，除了$PID�?PPID

4.fork子进�E�时�l�承父进�E�的�q�程名，在exec*执行命��o时才由exec*替换为子�q�程对应的命令，同一�q�程的命令名可以�׃��个个exec*��L��多次的改�?/strong>

[注]对于linux�q�_��Q�JB上就是这��L��Q�其它��^��C��好发表意见，当然对于2中的两个唯一有一个例外，��是在kenerl  init的初�?
暂时找不到相兛_��考，也没有功力读源码�Q�所以此论是道听途说�U�别�Q�错误之处请指出�Ҏ��Q�如果没有改正的价值可一�W�而过

我觉得要先弄清楚sub shell的定义�?br style="word-wrap: break-word; line-height: normal; ">
查了些资料，发现subshell的定义有些�؜乱�?br style="word-wrap: break-word; line-height: normal; ">bashMan:

QUOTE:
Each command in a pipeline is executed as a separate process (i.e., in a subshell).

QUOTE:
When a simple command other than a builtin or shell function is to be executed, it is invoked in a
separate execution environment that consists of the following. Unless otherwise noted, the values are
inherited from the shell.

�q�个separate execution是subshell吗？
A. 在当前shell执行外部命��o�Q�如shell> date, 是fork+exec, ��不是subshell?
B. ()是fork一个child shell�Q�该child再fork+exec来执行命令。这个subshell和A中的"subshell"昄��是不同的�?br style="word-wrap: break-word; line-height: normal; ">
UNIX: The Textbook, by Syed Mansoor Sarvar, Robert Koretsky and Syed Aqeel Sarvar中提刎ͼ�

QUOTE:
A child shell is also called subshell

问题是fork+exec是fork一个child shell�Q�然后在该child shell中exec.
而执行脚�?shell>scriptname)�Ӟ��是fort一个child shell A�Q�该child shell A再fork一个child shell B, 在B中再exec.

那么child shell是指哪种情况�Q?br style="word-wrap: break-word; line-height: normal; ">

UNIX at Fermilab中的Important UNIX Concepts:

QUOTE:
When you give the shell a command associated with a compiled executable or shell script, the shell
creates, or forks, a new process called a subshell.

外部命��o也在subshell中执行�?br style="word-wrap: break-word; line-height: normal; ">

QUOTE:
To execute most built-in commands, the shell forks a subshell which executes the command directly (no
exec system call). For the built-in commands cd, set, alias and source, the current shell executes the
command; no subshell is forked.

shell> built-inCommands�q�样执行�Ӟ��大部分内部命令也是在subshell中执行�?br style="word-wrap: break-word; line-height: normal; ">可见�Q�UNIX at Fermilab认�ؓfork 一个child shell��是subshell, 不管是fork-fork+exec, �q�是 fork+exec�?br>
我刚才又�ȝ��了下ABS�Q�定义与我的理解不一�?br style="word-wrap: break-word; line-height: normal; ">

QUOTE:
A subshell is a separate instance of the command processor -- the shell that gives you the prompt at the
console or in an xterm window. Just as your commands are interpreted at the command line prompt, similarly
does a script batch-process a list of commands. Each shell script running is, in effect, a subprocess (child
process) of the parent shell.
./script也是external_cmd的一�U�啊�Q�都是fork-exec�Q�至于external-cmd再作什么动作完全是external-cmd�?/td>

c++ 学习 2010-06-25 16:35 发表评论

shell metacharacters 与IFS讨论

c++ 学习 — Fri, 25 Jun 2010 08:29:00 GMT
good job!
�^�算有�h看得懂了�?/span>

不過�Q�要細說的話�Q�要扯上 shell �?interpret 一�?command line 時的 priority �?/span>
基本上，光��序如下：
1�Q�將 line 拆成 words �Q�IFS很重要）
2�Q�括�?alias
3�Q�擴�?�?�?/span>
4�Q�擴�?~
5�Q�擴�?$variable, $(command), `command`
6�Q�重�i�再拆成 words
7�Q�括�?wildcards
8�Q�處�?I/O redirection
9�Q�載入命令運�?/span>
如果大家有O'Reilly英文版的 Learning the Bash(2nd)的話�Q�請多端詳p178的圖�Q�細��略異�Q?/span>

回到LZ的問��，看上�?5 �?6 的順序然後才�?9 �?/span>
也就是在 6 重組命��o�?$A 已經完成替換�Q�當時的 environment 是沒賦��|��
因此重組後就�?A=B echo
然後在第 9 的步驟運行命令時�Q?A=B 是�� echo 命��o�?local environment�Q?/span>
不管是否 built-in command�Q�都不媄響當前的 shell �Q�不同的 shell 在實作上或有差異�Q?/span>
所以第二行�?echo $A 也是得到沒��c�?/span>

我通过eval说明赋值是成功的，而不�?5楼所说的赋��g��成功�?br style="word-wrap: break-word; line-height: normal; ">
�W�一步��?metacharacter�Q�与IFS没有关系

The following is a brief description of the shell's operation when it
reads and executes a command.  Basically, the shell does the following:

  1. Reads its input from a file (*note Shell Scripts::), from a string
   supplied as an argument to the `-c' invocation option (*note
   Invoking Bash::), or from the user's terminal.

  2. Breaks the input into words and operators, obeying the quoting
   rules described in *Note Quoting::.  These tokens are separated by
   `metacharacters'.  Alias expansion is performed by this step
   (*note Aliases::).
QUOTE:
`IFS'
   A list of characters that separate fields; used when the shell
   splits words as part of expansion.
`metacharacter'
   A character that, when unquoted, separates words.  A metacharacter
   is a `blank' or one of the following characters: `|', `&', `;',
   `(', `)', `<', or `>'.
8.05 命��o行的评�h�Q�evaluation�Q?br style="word-wrap: break-word; line-height: normal; ">下面是C shell 解释命��o行的��序�Q?br style="word-wrap: break-word; line-height: normal; ">1. 历史替换
2. 分裂词（包括�Ҏ��字符�Q?br style="word-wrap: break-word; line-height: normal; ">3. 更新历史�?br style="word-wrap: break-word; line-height: normal; ">4. 解释单引��P��'�Q?�?双引��P��"�Q?br style="word-wrap: break-word; line-height: normal; ">5. 别名替换
6. 输入和输出的重定向（�?>  < �?|�Q?br style="word-wrap: break-word; line-height: normal; ">7. 变量替换
8. 命��o替换
9. 文�g名扩�?br style="word-wrap: break-word; line-height: normal; ">�Q�Bourne shell 的解释顺序本质上是一��L��Q�除了它不执行历史替换和别名替换之外�Q?br style="word-wrap: break-word; line-height: normal; ">
所�?br style="word-wrap: break-word; line-height: normal; ">A=B  echo $A

的执行过�E�应该是�q�样的：
1. 没有历史操作�W�，因此不进行历史替换（Bourne shell 不执行这一步）
2. 分裂词，每碰到未加引��L��I�白字符��׃��产生一个新“�?#8221;。这些词�?A=B、echo�?A�?br style="word-wrap: break-word; line-height: normal; ">3. shell ��命令行攑ֈ�历史列表中。（Bourne shell 不执行这一步）
4. 没有引号需要解�?br style="word-wrap: break-word; line-height: normal; ">5. 没有别名需要替�?br style="word-wrap: break-word; line-height: normal; ">6. 没有输入或输出重定向需要处�?br style="word-wrap: break-word; line-height: normal; ">7. shell注意到变�?A�Q��ƈ把它替换成空
8. shell��L��左单引号�Q�执行左单引号中的�Q何命令，�q�且��命令的输出插入到命令行中。在本例中，没有�q�方面的事需要做。（如果左单引号内有通配�W�或者变量，那么在shell�q�行左单引号中的命��o之前它们是不会被解释的）
9. shell��L��通配�W�。本例中没有�Q�不需要处�?br style="word-wrap: break-word; line-height: normal; ">10. shell 执行 A=B�Q?执行 echo �?/span>
8.05 命��o行的评�h�Q�evaluation�Q?br style="word-wrap: break-word; line-height: normal; ">下面是C shell 解释命��o行的��序�Q?br style="word-wrap: break-word; line-height: normal; ">1. 历史替换
2. 分裂词（包括�Ҏ��字符�Q?br style="word-wrap: break-word; line-height: normal; ">3. 更新历史�?br style="word-wrap: break-word; line-height: normal; ">4. 解释单引��P��'�Q?�?双引��P��"�Q?br style="word-wrap: break-word; line-height: normal; ">5. 别名替换
6. 输入和输出的重定向（�?>  < �?|�Q?br style="word-wrap: break-word; line-height: normal; ">7. 变量替换
8. 命��o替换
9. 文�g名扩�?br style="word-wrap: break-word; line-height: normal; ">�Q�Bourne shell 的解释顺序本质上是一��L��Q�除了它不执行历史替换和别名替换之外�Q?br style="word-wrap: break-word; line-height: normal; ">
所�?br style="word-wrap: break-word; line-height: normal; ">A=B  echo $A

的执行过�E�应该是�q�样的：
1. 没有历史操作�W�，因此不进行历史替换（Bourne shell 不执行这一步）
2. 分裂词，每碰到未加引��L��I�白字符��׃��产生一个新“�?#8221;。这些词�?A=B、echo�?A�?br style="word-wrap: break-word; line-height: normal; ">3. shell ��命令行攑ֈ�历史列表中。（Bourne shell 不执行这一步）
4. 没有引号需要解�?br style="word-wrap: break-word; line-height: normal; ">5. 没有别名需要替�?br style="word-wrap: break-word; line-height: normal; ">6. 没有输入或输出重定向需要处�?br style="word-wrap: break-word; line-height: normal; ">7. shell注意到变�?A�Q��ƈ把它替换成空
8. shell��L��左单引号�Q�执行左单引号中的�Q何命令，�q�且��命令的输出插入到命令行中。在本例中，没有�q�方面的事需要做。（如果左单引号内有通配�W�或者变量，那么在shell�q�行左单引号中的命��o之前它们是不会被解释的）
9. shell��L��通配�W�。本例中没有�Q�不需要处�?br style="word-wrap: break-word; line-height: normal; ">10. shell 执行 A=B�Q?执行 echo �?/span>

c++ 学习 2010-06-25 16:29 发表评论