编程版面的大牛小牛，发贴前看过来！

linuxfavor

[code:1]
#define _GNU_SOURCE
#define MAX_ARGS 10
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/types.h>

int main (int argc,char *argv[])
{
  size_t size=0;
  pid_t pid;
  const char delimiters[]=" \t";
  int result;
  char *args=NULL;
  char *myargv[MAX_ARGS+2];
  char *token;
  while(1)
  {
    if(args)
    {
        free(args);
        args=NULL;
    }
    fputs("TEST>",stdout);
    getline(&args,&size,stdin);
    memset(strchr(args,'\n'),'\0',1);
    token=strtok(args,delimiters);
    int i=0;
    do{
            myargv[i++]=token;
            if(i>MAX_ARGS+1) break;
    }
    while(token=strtok(NULL,delimiters));
    myargv[i]=NULL;
    if(!myargv[0]) continue;
    if(!strcmp(myargv[0],"OUT")) break;
    int j;
    pid = fork ();
    if (pid > 0)
        {
            waitpid (pid,&result,0);
        }
    else if (pid == 0)
        {
                if(execvp (myargv[0],&myargv[0])!=0)
                        _exit(EXIT_FAILURE);
        }
    else
        printf ("fail\n");
    if(result)
        printf("ERROR!!\n");
    }
  free(args);
  return 0;
}
[/code:1]

xuanyuanhaobo

[code:1]
Linux 是一个完整的核心，就是说，它是一个单一的巨大的程序，核心的功能组件可以访问它的所有的内部数据结构以及例程。另一种方法是使用一个微内核的结构，核心的功能片被分成独立的单元，互相之间有严格的通讯机制。这样通过配置进程向核心增加新的组件不花多少时间。比如你希望增加一个 NCR 810 SCSI 卡的 SCSI 驱动程序，你不需要把它连接到核心。否则你不得不配置并建立一个新的核心才能使用这个 NCR 810 。作为一种变通， Linux 允许在你需要的时候动态地加载和卸载操作系统的组件。 Linux 的模块是可以在系统启动之后任何时候动态连接到核心的代码块。它们可以在不被需要的时候从核心删除并卸载。大多数 Linux 核心模块是设备驱动程序，伪设备驱动程序比如网络驱动程序或文件系统。

你可以使用 insmod 和 rmmod 命令明确地加载和卸载 Linux 核心模块，或者在需要这些模块的时候由核心自己要求核心守护进程（ kerneld ）加载和卸载这些模块。在需要的时候动态地加载代码相当有吸引力，因为它让核心可以保持最小而且核心非常灵活。我当前的 Intel 核心大量使用模块，它只有 406K 大小。我通常只适用 VFAT 文件系统，所以我建立我的 Linux 核心，当我安装一个 VFAT 分区的时候自动加载 VFAT 文件系统。当我卸载 VFAT 文件系统的时候，系统探测到我不再需要 VFAT 文件系统模块，把它从系统中删除。模块也可以用来尝试新的核心代码而不需要每次都创建和重启动核心。但是，没有这么好的事情，使用核心模块通常伴随轻微的性能和内存开支。一个可加载模块必须提供更多的代码，这种代码和额外的数据结构会占用更多一点的内存。另外因为间接访问核心资源也让模块的效率轻微降低。

一旦 Linux 核心加载，它就和普通核心代码一样成为核心的一部分。它和任何核心代码拥有相同的权利和义务：换句话说， Linux 核心模块和所有的核心代码或设备驱动程序一样可能让核心崩溃。

既然模块在需要的时候可以使用核心资源，它们必须能够找到这些资源。比如一个模块需要调用 kmalloc() ，核心内存分配例程。当建立的时候（ build ），模块不知道内存中 kmalloc() 在哪里，所以当这个模块加载的时候，在模块能够工作之前，核心必须整理模块对于 kmmalloc() 的所有的引用。核心在核心符号表中保存了所有核心资源的列表，所以当模块加载的时候它可以解析模块中对于这些资源的引用。 Linux 允许模块堆栈（堆砌），就是一个模块需要另一个模块的服务。例如 VFAT 文件系统模块需要 FAT 文件系统模块的服务，因为 VFAT 文件系统或多或少是 FAT 文件系统上的扩展。一个模块需要另一个模块的服务或资源的情况和一个模块需要核心自己的服务和资源的情况非常相似，只不过这时请求的服务在另一个，此前已经加载的模块钟。当每一个模块加载的时候，核心修改它的符号表，把这个新加载的模块的所有输出的资源或符号加到核心符号表中。这意味着，当下一个模块加载的时候，它可以访问已经加载的模块的服务。

当时图卸载一个模块的时候，核心需要知道这个模块不在用，它还需要一些方法来通知它准备卸载的模块。用这种方法模块可以在它从核心删除之前释放它占用的任何的系统资源，例如核心内存或中断。当模块卸载的时候，核心把这个模块输出到核心符号表中所有的符号都删除。

除了写的不好的可加载模块可能破坏操作系统之外，还有另一个危险。如果你加载一个为比你当前运行的核心要早或迟的核心建立的模块会发生什么？如果这个模块执行一个核心例程而提供了错误的参数就会引起问题。核心可以选择防止这种情况，当模块加载的时候进行严格的版本检查。
[/code:1]

Estray

[code:1]hello world[/code:1]

yoti

[code:1]unit RTFEncode;

interface

uses SysUtils, Classes, LexAnalysis;

type

TRTFSyntaxLightor = class(TSyntaxLightor)
private
function HexToDec(s : string) : string;
function HexToRGB(s : string) : string;
protected
procedure WriteHead; override;
procedure WriteFoot; override;
procedure Encode(const s : string); override;
procedure AddStyle(const s : string; StyleIndex : integer); override;
end;
implementation
[/code:1]

freeant

代码
[code:1]
#include<iostream.h>
int main()
{
     printf("I love Linux.\n");
     return 0;
}


[/code:1]

phenixsen

[code:1]我也试试[/code:1]

funpig

[code:1]
code test
[/code:1]

ryebread

我试试：
[code:1]
do{
     goodgoodstudy();
     daydayup();
}while(!died);

[/code:1]

lokii

我也试一试...
[code:1]
#include<stdio.h>

int main(int argc ,char **argv)
{
    printf("Hello,world!\n");
    return 1;
}
[/code:1]

x2j

q我也试试
[code:1]

int main()
{
    cout<<this is test << endl;
}

[/code:1]

ppshw

[code:1]
int main（）
{
printf("hello！\n");
}
[/code:1]

7lili7

我也来实施
[code]
int main()
{

printf("tinghaoyong ");
}

7lili7

[code]
main()
{
printf("在世一次")；
}
[code]

7lili7

在给此机会
[code:1]
xie xie
[/code:1]

yuehe

[code:1]
en
[/code:1]