#include 

 

;

 std;

 

 a1,)

{

    va_list argp;

    int i;

    int  ary[N];

 

    va_start(argp,a1);

    ary[0]=a1;

    for(i=1;i< N;i++)

       ary[i]=va_arg(argp,int);

    va_end(argp); 

    for(i=0;i< N;i++)

       cout<<ary[i]<<endl;

}

 

 main()

{

    Stdarg(5,12,64,34,23);

}

(一)写一个简单的可变参数的C函数

下面我们来探讨如何写一个简单的可变参数的C函数.写可变参数的
C函数要在程序中用到以下这些宏:
void va_start( va_list arg_ptr, prev_param );

type va_arg( va_list arg_ptr, type );

void va_end( va_list arg_ptr );
va在这里是variable-argument(可变参数)的意思.
这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个
头文件.下面我们写一个简单的可变参数的函数,改函数至少有一个整数
参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值.
void simple_va_fun(int i, ...)
{
va_list arg_ptr;
int j=0;

va_start(arg_ptr, i);
j=va_arg(arg_ptr, int);
va_end(arg_ptr);
printf("%d %d\n", i, j);
return;
}
我们可以在我们的头文件中这样声明我们的函数:
extern void simple_va_fun(int i, ...);
我们在程序中可以这样调用:
simple_va_fun(100);
simple_va_fun(100,200);
从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:
1)首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变
量是指向参数的指针.
2)然后用va_start宏初始化变量arg_ptr,这个宏的第二个参数是第
一个可变参数的前一个参数,是一个固定的参数.
3)然后用va_arg返回可变的参数,并赋值给整数j. va_arg的第二个
参数是你要返回的参数的类型,这里是int型.
4)最后用va_end宏结束可变参数的获取.然后你就可以在函数里使
用第二个参数了.如果函数有多个可变参数的,依次调用va_arg获
取各个参数.
如果我们用下面三种方法调用的话,都是合法的,但结果却不一样:
1)simple_va_fun(100);
结果是:100 -123456789(会变的值)
2)simple_va_fun(100,200);
结果是:100 200
3)simple_va_fun(100,200,300);
结果是:100 200

我们看到第一种调用有错误,第二种调用正确,第三种调用尽管结果
正确,但和我们函数最初的设计有冲突.下面一节我们探讨出现这些结果
的原因和可变参数在编译器中是如何处理的.

(二)可变参数在编译器中的处理

我们知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,
由于1)硬件平台的不同 2)编译器的不同,所以定义的宏也有所不同,下
面以VC++中stdarg.h里x86平台的宏定义摘录如下(’\’号表示折行):

typedef char * va_list;

#define _INTSIZEOF(n) \
((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )

#define va_arg(ap,t) \
( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

#define va_end(ap) ( ap = (va_list)0 )

定义_INTSIZEOF(n)主要是为了某些需要内存的对齐的系统.C语言的函
数是从右向左压入堆栈的,图(1)是函数的参数在堆栈中的分布位置.我
们看到va_list被定义成char*,有一些平台或操作系统定义为void*.再
看va_start的定义,定义为&v+_INTSIZEOF(v),而&v是固定参数在堆栈的
地址,所以我们运行va_start(ap, v)以后,ap指向第一个可变参数在堆
栈的地址,如图:

高地址|-----------------------------|
|函数返回地址 |
|-----------------------------|
|....... |
|-----------------------------|
|第n个参数(第一个可变参数) |
|-----------------------------|<--va_start后ap指向
|第n-1个参数(最后一个固定参数)|
低地址|-----------------------------|<-- &v
图( 1 )

然后,我们用va_arg()取得类型t的可变参数值,以上例为int型为例,我
们看一下va_arg取int型的返回值:
j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );
首先ap+=sizeof(int),已经指向下一个参数的地址了.然后返回
ap-sizeof(int)的int*指针,这正是第一个可变参数在堆栈里的地址
(图2).然后用*取得这个地址的内容(参数值)赋给j.

高地址|-----------------------------|
|函数返回地址 |
|-----------------------------|
|....... |
|-----------------------------|<--va_arg后ap指向
|第n个参数(第一个可变参数) |
|-----------------------------|<--va_start后ap指向
|第n-1个参数(最后一个固定参数)|
低地址|-----------------------------|<-- &v
图( 2 )

最后要说的是va_end宏的意思,x86平台定义为ap=(char*)0;使ap不再
指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不
会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的.
在这里大家要注意一个问题:由于参数的地址用于va_start宏,所
以参数不能声明为寄存器变量或作为函数或数组类型.
关于va_start, va_arg, va_end的描述就是这些了,我们要注意的
是不同的操作系统和硬件平台的定义有些不同,但原理却是相似的.

(三)可变参数在编程中要注意的问题

因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,
可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能
地识别不同参数的个数和类型.
有人会问:那么printf中不是实现了智能识别参数吗?那是因为函数
printf是从固定参数format字符串来分析出参数的类型,再调用va_arg
的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通
过在自己的程序里作判断来实现的.
另外有一个问题,因为编译器对可变参数的函数的原型检查不够严
格,对编程查错不利.如果simple_va_fun()改为:
void simple_va_fun(int i, ...)
{
va_list arg_ptr;
char *s=NULL;

va_start(arg_ptr, i);
s=va_arg(arg_ptr, char*);
va_end(arg_ptr);
printf("%d %s\n", i, s);
return;
}
可变参数为char*型,当我们忘记用两个参数来调用该函数时,就会出现
core dump(Unix) 或者页面非法的错误(window平台).但也有可能不出
错,但错误却是难以发现,不利于我们写出高质量的程序.
以下提一下va系列宏的兼容性.
System V Unix把va_start定义为只有一个参数的宏:
va_start(va_list arg_ptr);
而ANSI C则定义为:
va_start(va_list arg_ptr, prev_param);
如果我们要用system V的定义,应该用vararg.h头文件中所定义的
宏,ANSI C的宏跟system V的宏是不兼容的,我们一般都用ANSI C,所以
用ANSI C的定义就够了,也便于程序的移植.

小结:
可变参数的函数原理其实很简单,而va系列是以宏定义来定义的,实
现跟堆栈相关.我们写一个可变函数的C函数时,有利也有弊,所以在不必
要的场合,我们无需用到可变参数.如果在C++里,我们应该利用C++的多
态性来实现可变参数的功能,尽量避免用C语言的方式来实现. 

摘自：http://blog.csdn.net/zxianrong/archive/2009/01/04/3706405.aspx

　　正常情况下，一个进程的运行一般是不会影响到其他正在运行的进程的。但是对于某些有特殊要求的如以独占方式使用串行口等硬件设备的程序就要求在其进程运行期间不允许其他试图使用此端口设备的程序运行的，而且此类程序通常也不允许运行同一个程序的多个实例。这就引出了进程互斥的问题。

　　实现进程互斥的核心思想比较简单：进程在启动时首先检查当前系统是否已经存在有此进程的实例，如果没有，进程将成功创建并设置标识实例已经存在的标记。此后再创建进程时将会通过该标记而知晓其实例已经存在，从而保证进程在系统中只能存在一个实例。具体可以采取内存映射文件、有名事件量、有名互斥量以及全局共享变量等多种方法来实现。

// 创建互斥量
HANDLE m_hMutex = CreateMutex(NULL, FALSE, "Sample07");
// 检查错误代码
if (GetLastError() == ERROR_ALREADY_EXISTS) {
　// 如果已有互斥量存在则释放句柄并复位互斥量
　CloseHandle(m_hMutex);
　m_hMutex = NULL;
　// 程序退出
　return FALSE;
}

        上面这段代码演示了有名互斥量在进程互斥中的用法。代码的核心是CreateMutex（）对有名互斥量的创建。CreateMutex（）函数可用来创建一个有名或无名的互斥量对象，其函数原型为：

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
　BOOL bInitialOwner, // 初始化互斥对象的所有者
　LPCTSTR lpName // 指向互斥对象名的指针
);

如果函数成功执行，将返回一个互斥量对象的句柄。如果在CreateMutex（）执行前已经存在有相同名字的互斥量，函数将返回这个已经存在互斥量的句柄，并且可以通过GetLastError（）得到错误代码ERROR_ALREADY_EXIST。可见，通过对错误代码ERROR_ALREADY_EXIST的检测可以实现CreateMutex（）对进程的互斥。

        建立互斥体，用来同步。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。

参数
lpMutexAttributes
指向一个SECURITY_ATTRIBUTES结构的指针，这个结构决定互斥体句柄是否被子进程继承。    
bInitialOwner
布尔类型，决定互斥体的创建者是否为拥有者
lpName
指向互斥体名字字符串的指针。互斥体可以有名字。
互斥体的好处是可以在进程间共享

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/laura0502/archive/2009/01/20/3838732.aspx


摘自：http://blog.csdn.net/laura0502/archive/2009/01/20/3838732.aspx

下面是一段代码示例

#include <stdlib.h>
#include <stdio.h>

void fn4(void),fn1(void),fn3(void),fn2(void);

int main(void)
{
    atexit(fn2);
    atexit(fn1);
    atexit(fn3);
    atexit(fn4);
    printf("this is main function\n");
    system("pause");
}

void fn1()
{
    printf("exe after ");
    system("pause");
}

void fn2()
{
    printf("main function");
    system("pause");
    
}


void fn3()
{
    printf("hello\n");
    system("pause");
}

void fn4()
{
    printf("hi\n");
    system("pause");
}

2.1基本内置类型

² char类型通常是单个机器字节，wchar_t类型用于扩展字符集，比如汉字等。

² 整型int、short和long都默认为带符号型。

² float型只能保证6位有效数字，而double型至少可以保证10位有效数字。

2.2 字面值常量

² 不能在单词中间断开一行，但可以通过使用反斜线符号巧妙实现。

2.3变量

² C++两种表达方式：左值：可以出现在赋值语句的左边或右边‚只能出现在赋值的右边。

² 变量名，即变量的标识符，可以由字母、数字和下划线组成，以字母和下划线开头，并且区分大小写字母。

² C++两种初始化变量的形式：复制初始化，语法用等号‚直接初始化，把初始化式放在括号中。

² C++中初始化和赋值是两种不通的操作。

² 在函数体外定义的变量都初始化为0，在函数体里定义的内置类型变量不进行自动初始化。

² 每个内置类型的对象都要初始化。虽然这么做不总是必需的，但更加容易和安全。

² 变量的定义用于为变量分配存储空间，还可以为变量指定初始值。声明用于向程序表明变量的类型和名字。可以通过使用extern关键字声明变量名而不定义它。Extern声明不是定义，也不分配存储空间。事实上，它只是说明变量定义在程序的其他地方。程序中变量可以声明多次，但只能定义一次。

² 用来区分名字的不通意义的上下文称为作用域。作用域是程序的一段区域。

² 通常把一个对象定义在它首次使用的地方是一个很好的办法。

2.4 const限定符

² const限定符把一个对象转换成一个常量。在全局作用域声明的const变量是定义该对象的文件的局部变量。此变量只存在于那个文件中，不能被其他文件访问。通过指定const变量为extern，就可以在整个程序中访问const对象。

2.5 引用

² 引用就是对象的另一个名字，主要用作函数的形式参数。

² 当引用初始化后，只要该引用存在，它就保持绑定到初始化时指向的对象。不可能将引用绑定到另一个对象。

² 将普通的引用绑定到const对象是不合法的。

2.7 枚举

² 默认地，第一个枚举成员赋值是0，后面的每个枚举成员赋值比前面的大1。

² 枚举成员值可以是不唯一的。

² 不能改变枚举成员的值。枚举成员本身就是一个常量表达式。

2.8 类类型

² 如果使用class关键字来定义类，那么定义在第一个访问标号前的任何成员都隐式指定为private;使用struct关键字，这些成员都是public。

² 进程的创建

在UNIX中，系统调用fork是创建新进程的方法，原型如下：

#include <unistd.h>

pid_t fork();

调用fork创建的子进程，将共享父进程的代码空间，复制父进程数据空间，此时子进程会获得父进程的所有变量的一份拷贝。

如果fork调用失败，返回-1；如果调用成功，则在父进程中返回子进程的标识号，在子进程中返回0。

实例：

² 新程序的执行

1. exec函数族

v exec函数族用新程序的代码覆盖进程中原来的程序代码，并且使进程使用函数提供的命令行参数和环境变量去执行新的程序。

v 函数族调用成功时，系统把一个新程序的地址空间代替调用进程的地址空间并装入新程序的内容，同事忽略原exec函数的返回，不执行exec函数后的所有语句，系统将从新程序的main函数处开始执行。如果调用失败，返回-1。

2. fork-exec 模型 （子进程和父进程的执行顺序问题？）

3. vfork-exec 模型

v 函数vfork与fork区别：vfork创建的子进程并不复制父进程的数据，在随后的exec调用中系统会复制新程序的数据到内存中‚父进程以vfork方式创建子进程后将被阻塞，直到子进程退出或执行exec调用才继续运行。

4. system 模型

#include<stdlib.h>

Int system(char *string)

函数system阻塞调用它的进程，并执行字符串string中shell命令。

² 进程的休眠

unsigned int sleep(unsigned int seconds);

进程调用函数sleep后休眠seconds秒，直到时间结束或收到不可忽略信号为止。

² 进程的终止

void exit(int status);

参数status的低8位记载了进程的终止状态，进程终止后将这个状态返回给它的父进程

² 进程的同步

pid_t wait(int *status);

pid_t waitpid(pid_t pid,int *status,int options);

v Wait挂起调用它的进程，直到它的任一子进程退出或者收到一个不能忽略的信号为止，如果在父进程执行wait调用前就已经有子进程退出，则立刻返回。函数成功调用后返回结束运行子进程的ID，否则返回-1。

v Waitpid用于多个子进程的操作，如等待特定子进程等。

实例1：

#include <stdio.h>
#include <unistd.h>
int  main()
{
    pid_t i,j;
    int status;
    if((i=fork())==0)
    {
        fprintf(stderr,"child begin.pid=%d\n",getpid());
        sleep(40);
        fprintf(stderr,"child end.pid=%d\n",getpid());
        exit(2);
    }
    j=wait(&status);
    fprintf(stderr,"child pid=%d,exit pid=%d,status=%d",i,j,status);
}

实例2：

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
int main()
{
    pid_t pid1,pid2,pid3;
    int status;
    
    while(1)
    {
        if((pid1=fork())<0)
            exit (1);
        else if(pid1==0)
        {
            sleep(30);
            exit(0);
        }
        if((pid2=fork())<0)
            exit (1);
        else if(pid2==0)
        {
            sleep(40);
            exit(0);
        }    
        fprintf(stderr,"fork child,pid=[%d][%d]\n",pid1,pid2);
        pid3=wait(&status);
        kill(pid1,SIGTERM);
        kill(pid2,SIGTERM);
        fprintf(stderr,"kill child.pid=[%d],exit pid=%d,status=%d\n",pid1,pid2,pid3,status);
        pid3=wait(&status);
        sleep(1);
    }
}

1.1编写简单的C++程序

²        操作系统通过main函数返回的值来确定程序是否成功执行完毕。返回0值表明程序成功执行完毕。

²        Main函数的返回值必须是int型，该类型表示整数。Int类型是内置类型，该类型是由C++语言定义的。

1.2初窥输入/输出

²        4个IO对象：cin标准输入；cout标准输出；cerr标准错误；clog对象用于产生程序执行的一般信息。

²        Endl是一个特殊值，称为操纵符，将它写入输出流时，具有输出换行效果，并刷新与设备相关联的缓冲区。通过刷新缓冲区，用户可立即看到写入到流中的输出。

²        使用命名空间，程序员可以避免由于无意中使用了与库中所定义的名字相同的名字而引致冲突

²        在写C++程序时，大部分出现空格符的地方可用换行符代替。这条规则的一个例外是字符串字面值中的空格符不能用换行符代替。另一个例外是空格符不允许出现在预处理指示中。

1.3关于注释

²        程序通常混用两种注释形式。注释对一般用于多行解释，而双斜线注释则常用于半行或单行的标记。

²        注释总是以/*开始并以*/结束。这意味着，一个注释对不能出现在另一个注释对中。当注释掉程序的一大部分时，似乎最简单的办法就是在临时忽略的区域前后放一个注释对。问题是如果那段代码已经有了注释对，那么新插入的注释对将提前终止。临时忽略一段代码更好的方法，用编辑器在要忽略的每一行代码前面插入单行注释。

1.4控制结构

²        按错误报告的顺序改正错误是个好习惯，通常一个错误可能会产生一连串的影响，并导致编译器报告比实际多得多的错误。最好在每次修改后或者最多改正了一些显而易见的错误后，就重新编译代码。

²        读入未知数目的输入

#include<iostream> 

int main() 
{ 
    int sum=0; 
    int val; 
    while(std::cin>>val) 
        sum+=val; 
    std::cout<<sum<<std::endl; 
    return 0; 

}

² 进程和线程：一个进程可以拥有多个线程。线程没有独立的资源，它共享进程的ID，共享进程的资源。线程是UNIX中最小的调度单位。

² 前台进程和后台进程：用户在Shell提示符下键入命令，创建进程，此后该进程接管终端，Shell中不能再输入其他的命令，知道进程执行完毕，才将终端控制权返回Shell并显示用户提示符。这样的进程就是前台进程。‚如果用户再输入Shell命令时，在命令串后加上“&”,shell将不等待进程执行完毕就直接返回，于是就可以同事运行进程和执行shell操作，这样的进程就是后台进程，后台进程并不接管终端，所以必须是非交互式的。

² 守护进程：与终端无关，常驻后台执行的特殊进程。UNIX中最著名的两个守护进程：sysproc进程，它是UNIX的第一个进程，标识号为0，能合理地调度系统中运行的进程，负责将进程从硬盘交换区调入内如或者讲进程从内存调到硬盘交换区‚init进程，系统初始化进程，标识号1，是除sysproc外所有进程的祖先。

² 进程状态：运行态：进程已经分配到CPU，正在处理机上执行时的状态。同意时刻处于运行态的进程数不能大于CPU的数目。运行态可分为用户态和核心态。如果进程正在运行用户代码，进程处于用户态。如果进程出现系统调用或者系统中断，运行操作系统内部代码，进程处于核心态。‚就绪态：进程已具备运行条件，但其他进程正在用CPU，所以暂时不能运行而等待分配CPU的状态。处于就绪态的进程一旦获得了CPU就能立刻运行。ƒ睡眠态：进程正在等待某种事件的发生而暂时不能运行的状态。处于睡眠态的进程尚不具备运行条件，即使CPU空闲，它也无法使用。

² 进程标识号：UNIX中每个进程具有唯一的标识号，操作系统采用一个非负整数标识每一个进程。

UNIX中读取进程ID号的函数如下：

#include <sys/types.h>

#include<unistd.h>

pid_t getpid();    //返回当前进程ID

pid_t getpgrp();   //返回当前进程组ID

pid_t getppid();   //返回父进程ID

类型pid_t是进程标识类型，可以用long或者int代替

² 进程的用户标识号：当进程由用户启动时，该用户的标识号就是进程的实际用户标识，该用户的组标识号就是进程实际组标识号。进程的实际用户标识号和实际组标识号仅用于系统记账，参与权限检查的是进程的有效用户标识号和有效组标识号。一般情况下，实际标识号和有效标识号相一致。

UNIX中读取用户ID号函数如下：

#include<unistd.h>

uid_t getuid();    //返回进程实际用户ID

uid_t geteuid();   //返回进程有效用户ID

gid_t getgid();    //返回进程实际组ID

gid_t getegid();   //返回进程有效组ID

实例：

#include <sys/types.h> 
#include <unistd.h> 

void main() 
{ 
   printf("pid=%d,gid=%d,ppid=%d\n",getpid(),getpgrp(),getppid()); 
   printf("uid=%d,euid=%d,gid=%d,egid=%d\n",getuid(),geteuid(),getgid(),getegid()); 
} 

² 进程命令行 

实例：

#include <stdio.h> 

void main(int argc,char * argv[]) 
{ 
   int i; 
   fprintf(stderr,"argc=%d\n",argc); 
   for(i=0;i<argc;i++) 
     fprintf(stderr,"argv[%d]=%s\n",i,argv[i]); 
} 

² 环境变量

UNIX中，存储了一系列的变量，在shell下执行"env"命令查看。

环境变量分为系统环境变量和用户环境变量。系统环境变量在注册师自动设置。用户环境变量在shell中使用赋值命令和export命令设置。如下例设置了变量ZYX，再将其转化为用户环境变量：

   #ZYX=/u/zyx     //赋值语句

   #export ZYX     //export语句

   #env |grep zyx  //验证变量

   ZYX=/u/zyx

² 获取环境变量的方法：

全局变量法。

UNIX用一个指针数组来存储全部环境值：

extern char **environ;

实例：

#include <stdio.h> 

extern char **environ; 
int main() 
{ 
   char **p=environ; 
   while(*p) 
   { 
      fprintf(stderr,"%s\n",*p); 
      p++; 
   } 
} 

‚函数调用法。

UNIX中操作环境变量的函数如下：

#include <stdlib.h>

char *getenv(char *name);  

int putenv(const char *string); 

函数getenv以字符串形式返回环境变量name的取值，如果参数name为NULL或者环境变量列表无name变量，返回NULL。

函数putenv增加、修改或删除环境变量。参数string指向一个字符串，格式为“name=value”。如果环境列表中没有name变量，则增加变量并设置值为"value"；如果变量已经存在，则更改其值为"value";如果value为空，在删除环境变量name的值。函数成功时返回非0值，否则返回0。

实例：

#include <stdlib.h> 
#include <stdio.h> 
int main(int argc,char **argv) 
{ 
  int i; 
  for(i=1;i<argc;i++) 
    fprintf(stderr,"%s=%s\n",argv[i],getenv(argv[i]));   
}