va_list和vsnprintf、getopt

原理解释:

VA_LIST 是在C语言中解决变参问题的一组宏,在<stdarg.h>头文件下。

VA_LIST的用法:     
     
1)首先在函数里定义一具VA_LIST型的变量,这个变量是指向参数的指针
     
2)然后用VA_START宏初始化变量刚定义的VA_LIST变量,这个宏的第二个参数是第一个可变参数的前一个参数,是一个固定的参数。
     
3)然后用VA_ARG返回可变的参数,VA_ARG的第二个参数是你要返回的参数的类型。
     
4)最后用VA_END宏结束可变参数的获取。然后你就可以在函数里使用第二个参数了。如果函数有多个可变参数的,依次调用VA_ARG获取各个参数。

VA_LIST
在编译器中的处理:

(1)在运行VA_START(ap,v)以后,ap指向第一个可变参数在堆栈的地址。
2VA_ARG()取得类型t的可变参数值,在这步操作中首先apt = sizeof(t类型),让ap指向下一个参数的地址。然后返回ap-sizeof(t类型)t类型*指针,这正是第一个可变参数在堆栈里的地址。然后用*取得这个地址的内容。
3VA_END(),X86平台定义为ap = ((char*)0),使ap不再指向堆栈,而是跟NULL一样,有些直接定义为((void*)0),这样编译器不会为VA_END产生代码,例如gccLinuxX86平台就是这样定义的。

要注意的是:由于参数的地址用于VA_START宏,所以参数不能声明为寄存器变量,或作为函数或数组类型。

使用VA_LIST应该注意的问题:
  
1)因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能地识别不同参数的个数和类型.也就是说,你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的.
  
2)另外有一个问题,因为编译器对可变参数的函数的原型检查不够严格,对编程查错不利.不利于我们写出高质量的代码。
 

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

va_list ap; //声明一个变量来转换参数列表  
va_start(ap,fmt);          //初始化变量  
va_end(ap);     //结束变量列表,va_start成对使用  
可以根据va_arg(ap,type)取出参数  

已经经过调试成功的输出程序

#include<stdio.h>
#include <stdarg.h>

#define bufsize 80
char buffer[bufsize];

int vspf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);

cnt = vsnprintf(buffer,bufsize ,fmt, argptr);

va_end(argptr);

return(cnt);
}

int main(void)
{
int inumber = 30;

float fnumber = 90.0;

char string[4] = "abc";

vspf("%d %f %s", inumber, fnumber, string);

printf("%s\n", buffer);

return 0;
}






头文件:

#include <stdarg.h>

函数声明:

int vsnprintf(char*str,size_tsize,constchar*format,va_listap);

参数说明:

  1. char *str [out],把生成的格式化的字符串存放在这里.
  2. size_t size [in], str可接受的最大字节数,防止产生数组越界.
  3. const char *format [in],指定输出格式的字符串,它决定了你需要提供的可变参数的类型、个数和顺序。
  4. va_list ap [in], va_list变量. va:variable-argument:可变参数

函数功能:将可变参数格式化输出到一个字符数组。

用法类似于vsprintf,不过加了size的限制,防止了内存溢出(sizestr所指的存储空间的大小)。

返回值:执行成功,返回写入到字符数组str中的字符个数(不包含终止符),最大不超过size;执行失败,返回负值,并置errno.[1]

备注:

linux环境下是:vsnprintf

VC6环境下是:_vsnprintf


2用法实例

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

char *make_message(const char *fmt, ...) {

/* 初始时假设我们只需要不超过100字节大小的空间 */

int n, size = 100;

char *p;

va_list ap;

if ( (p = (char *) malloc(size*sizeof(char))) == NULL)

return NULL;

while (1) {

/* 尝试在申请的空间中进行打印操作 */

va_start(ap, fmt);

n = vsnprintf (p, size, fmt, ap);

va_end(ap);

/* 如果vsnprintf调用成功,返回该字符串 */

if (n > -1 && n < size)

return p;

/* vsnprintf调用失败(n<0),或者p的空间不足够容纳size大小的字符串(n>=size),尝试申请更大的空间*/

size *= 2; /* 两倍原来大小的空间 */

if ((p = (char *)realloc(p, size*sizeof(char))) == NULL)

return NULL;

}

}

int main() {

/* 调用上面的函数 */

char* str = make_message("%d,%d,%d,%d",5,6,7,8);

printf("%s\n",str);

free(str);

/* we allocate the memory in the make_message function, so we should release it by caller(main function). */

return 0;

}








linux 中解析命令行参数(getopt_long用法)optarg,optind 


getopt_long支持长选项的命令行解析,使用man getopt_long,得到其声明如下:
#include <getopt.h>
int getopt_long(int argc, char * const argv[],  const char *optstring,  const struct option *longopts, int *longindex);
int getopt_long_only(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);
说明:函数中的argc和argv通常直接从main()到两个参数传递而来。optsting是选项参数组成的字符串,如果该字符串里任一字母后有冒号,那么这个选项就要求有参数。下一个参数是指向数组的指针,这个数组是
option结构数组,option结构称为长选项表,其声明如下:
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
结构中的元素解释如下:
const char *name:选项名,前面没有短横线。譬如"help"、"verbose"之类。
int has_arg:描述长选项是否有选项参数,如果有,是哪种类型的参数,其值见下表:
符号常量             数值            含义
no_argument            0            选项没有参数
required_argument      1            选项需要参数
optional_argument      2            选项参数是可选的
int *flag:
如果该指针为NULL,那么getopt_long返回val字段的值;
如果该指针不为NULL,那么会使得它所指向的结构填入val字段的值,同时getopt_long返回0
int val:
如果flag是NULL,那么val通常是个字符常量,如果短选项和长选项一致,那么该字符就应该与optstring中出现的这个选项的参数相同;
最后一个参数:longindex参数一般赋为NULL即可;如果没有设置为NULL,那么它就指向一个变量,这个变量会被赋值为寻找到的长选项在longopts中的索引值,这可以用于错误诊断。
注:GNU提供的getopt-long()和getopt-long-only()函数,其中,后者的长选项字串是以一个短横线开始的,而非一对短横线。
linux 命令行约定:
几乎所有的GNU/Linux程序都遵循一些命令行参数定义的约定。程序希望出现的参数可以分成两种:选项(options or flags)、其他类型的的参数。Options修饰了程序运行的方式,其他类型的参数则提供了输入(例如,输入文件的名称)。
对于options类型参数可以有两种方式:
1)短选项(short options):顾名思义,就是短小参数。它们通常包含一个连字号和一个字母(大写或小写字母)。例如:-s,-h等。
2)长选项(long options):长选项,包含了两个连字号和一些大小写字母组成的单词。例如,--size,--help等。
*注:一个程序通常会提供包括short options和long options两种参数形式的参数。
对于其他类型参数的说明:
这种类型的参数,通常跟随在options类型参数之后。例如,ls –s /功能为显示root目录的大小。’/ ’这个参数告诉ls要显示目录的路径。
getopt_long()函数使用规则:
(1)使用前准备两种数据结构
字符指针型变量
该数据结构包括了所有要定义的短选项,每一个选项都只用单个字母表示。如果该选项需要参数(如,需要文件路径等),则其后跟一个冒号。例如,三个短选项分别为‘-h’‘-o’‘-v’,其中-o需要参数,其他两个不需要参数。那么,我们可以将数据结构定义成如下形式:
const char *  const shor_options = “ho:v” ;
如果是否有参数是可选的,则在后面有两个冒号。
struct option 类型数组
该数据结构中的每个元素对应了一个长选项,并且每个元素是由四个域组成。通常情况下,可以按以下规则使用。
第一个元素,描述长选项的名称;
第二个选项,代表该选项是否需要跟着参数,需要参数则为1,反之为0;
第三个选项,可以赋为NULL;
第四个选项,是该长选项对应的短选项名称。
另外,数据结构的最后一个元素,要求所有域的内容均为0,即{NULL,0,NULL,0}。下面举例说明,还是按照短选项为‘-h’‘-o’‘-v’的例子,该数据结构可以定义成如下形式:
const struct option long_options = {
{  “help”,      0,   NULL,   ‘h’  },
{  “output”,    1,   NULL,   ‘o’  },
{  “verbose”,   0,   NULL,   ‘v’  },
{  NULL,      0,    NULL,   0  }
};
(2)调用方法
参照(1)准备的两个数据结构,则调用方式可为:
getopt_long( argc, argv, short_options, long_options, NULL);
(3)几种常见返回值
(a)每次调用该函数,它都会分析一个选项,并且返回它的短选项,如果分析完毕,即已经没有选项了,则会返回-1。
(b)如果getopt_long()在分析选项时,遇到一个没有定义过的选项,则返回值为‘?’,此时,程序员可以打印出所定义命令行的使用信息给用户。
(c)当处理一个带参数的选项时,全局变量optarg会指向它的参数
(d)当函数分析完所有参数时,全局变量optind(into argv)会指向第一个‘非选项’的位置
实践小例子:
view plaincopy to clipboardprint?
#include <stdio.h>
#include <getopt.h>
char *l_opt_arg;
char* const short_options = "nbl:";
struct option long_options[] = {
{ "name",     0,   NULL,    'n'     },
{ "bf_name",  0,   NULL,    'b'     },
{ "love",     1,   NULL,    'l'     },
{      0,     0,     0,     0},
};
int main(int argc, char *argv[])
{
int c;
while((c = getopt_long (argc, argv, short_options, long_options, NULL)) != -1)
{
switch (c)
{
case 'n':
printf("My name is XL.\n");
break;
case 'b':
printf("His name is ST.\n");
break;
case 'l':
l_opt_arg = optarg;
printf("Our love is %s!\n", l_opt_arg);
break;
}
}
return 0;
}
编译并运行:
[root@localhost liuxltest]# gcc -o getopt getopt.c
[root@localhost liuxltest]# ./getopt -n -b -l forever
My name is XL.
His name is ST.
Our love is forever!
[root@localhost liuxltest]#
[root@localhost liuxltest]# ./getopt -nb -l forever
My name is XL.
His name is ST.
Our love is forever!
[root@localhost liuxltest]# ./getopt -nbl forever
My name is XL.
His name is ST.
Our love is forever!
刚开始接触 一些处理命令行参数的操作,开始不太明白,用例子测试了一下,感觉比以前明了多了。
命令行参数有长参数如version, 还有短参数 如 v, 那么用这两个都可以。程序处理的时候,会首先把长参数转换成对应的短参数,如会把version转成v, 再进行 v 对应的操作就可以了。
命令行参数的选项,有的需要参数,有的不需要参数,或者有的参数是可选的,那么怎么区分呢?
首先,对这些选项,如何组织起来? 是以字符串的形式组织起来了。如我有一个程序,有两个选项,-a, -b, 我输入的时候是  ./a.out  -a -b, 那么中间会处理成这种 ab这种字符串的形式,这个字符串就是所有的命令行的输入选项。区别是否有参数就在于此。如果某个选项必须有参数,则这一选项后有一个参数,如果参数是可选的,则其后面有两个冒号。如
-a  是没有参数的, -b 后面必须有参数, -c 后面是否有参数是可选的。则短的命令行选项是:   ab:c::
下面我们通过一个简单的例子看一下。
#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
char *l_opt_arg;
const char* const short_options = "myl:";
struct option long_options[] = {
        { "name",      0,   NULL,    'm'}, //长选项对应的短选项参数, 第二个0表示选项后面无参数, 1为有参数,2为可选
        { "yourname",  0,   NULL,    'y'},
        { "love",      1,   NULL,    'l'},
        {      0,      0,      0,     0},
};
int main(int argc, char *argv[])
{
        int c, i;
        printf("before:\n");
        for (i = 1; i < argc; i++)
                printf("arg:%d\r\targv:%s\n", i, argv[i]);
        printf("\n");
        while((c = getopt_long (argc, argv, short_options, long_options, NULL)) != -1)
        {
               
                switch (c)
                {
                        case 'm':
                                printf("My name is A.\n");
                                break;
                        case 'y':
                                printf("His name is B.\n");
                                break;
                        case 'l':
                                l_opt_arg = optarg;
                                printf("Our love is %s!\n", l_opt_arg);
                                break;
                }
        }
        printf("optind:%d\n", optind);
        printf("\nafter:\n");
        for (i=1; i<argc; i++)
                printf("arg:%d\r\targv:%s\n", i, argv[i]);
        printf("................................\n");
        for (i = optind; i < argc; i++)
                printf("arg:%d\rargv:%s\n",i,argv[i]);
        return 0;
}
注意,此程序可接收的的选项有三个, 一个是m ,不带参数, y 不带参数, l  要求有参数。
那如果-m 不带参数,如果我写了参数,会怎么样呢?下面看测试
在调用 getopt_long 以后, optind 的值随之变化 。在while循环后,我们再把开始的命令行参数打印出来,看一下有什么不同。
把上面的代码命名为: getopt_long.c
编译,可执行文件为 a.out
$ gcc  getopt_long.c   
$ ./a.out -m -y
before:
arg:1 : -m
arg:2 : -y
My name is A.
His name is B.
optind:3
after:
arg:1 : -m
arg:2 : -y
$ ./a.out -m -y -l banana
before:
arg:1 : -m
arg:2 : -y
arg:3 : -l
arg:4 : banana
My name is A.
His name is B.
Our love is banana!
optind:5
after:
arg:1 : -m
arg:2 : -y
arg:3 : -l
arg:4 : banana
$./a.out -m lisi -y zhangsan  -l banana  aaa
before:
arg:1 : -m
arg:2 : lisi
arg:3 : -y
arg:4 : zhangsan
arg:5 : -l
arg:6 : banana
arg:7 : aaa
My name is A.
His name is B.
Our love is banana!
optind:5
after:
arg:1 : -m
arg:2 : -y
arg:3 : -l
arg:4 : banana
arg:5 : lisi
arg:6 : zhangsan
arg:7 : aaa
注意 argv 里面值的顺序已经和原来不一样了,对命令行的参数重新组织了一下顺序,也就是不认识的命令行参数,都放在了argv的最后,其中 optind 指向了这些没有被解释的参数的第一个。
optind有作用吧!如果你想输出哪些命令行参数没有被识别,可以打印出来
for (i=optind; i<argc; i++)
printf("%s\n", argv[i]);  即可
附:如果是长参数,则使用 --, 如 --help, 因为 -help时,(选项不需要参数的情况) 会把它当成 四个选项, -h -e -l -p. 所以使用长参数时,要用两个 横线 --




#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
const char* program_name;
void print_usage (FILE* stream, int exit_code)
{
        fprintf (stream, "Usage: %s options [ inputfile ... ]\n", program_name);
        fprintf (stream, " -h --help                       显示这个帮助信息.\n"
                         " -o --output filename 将输出定位到文件.\n"
                         " -v --version                  打印版本信息.\n");
        exit (exit_code);
}


int main (int argc, char* argv[])
{
        int next_option;//下一个要处理的参数符号
        int haveargv = 0;//是否有我们要的正确参数,一个标识


       
        const char* const short_options = "ho:v";


       
        const struct option long_options[] = {
                { "help",        0,     NULL,    'h' },
                { "output",      1,     NULL,    'o' },
                { "version",     0,     NULL,    'v' },
                { NULL,          0,     NULL,     0  }};//最后一个元素标识为NULL


       
        const char *output_filename = NULL;
       
        int verbose = 0;
       
        program_name = argv[0];


        do
        {
                next_option = getopt_long (argc, argv, short_options, long_options, NULL);
                switch (next_option)
                {
                        case 'h':    
                                haveargv = 1;
                                print_usage (stdout, 0);
                        case 'o':    
                               
                                output_filename = optarg;
                                haveargv = 1;
                                break;
                        case 'v':    
                                verbose = 1;
                                haveargv = 1;
                                break;
                        case ':':    
                                break;
                        case '?':    
                                print_usage (stderr, 1);
                        case -1:      
                                if (!haveargv)
                                {
                                        print_usage (stderr, 1);
                                 }
                                break;
                        default:      
                                print_usage (stderr, 1);
                                break;
                }
        }while (next_option != -1);


        printf("optind.................%d\n",optind);


        if (haveargv)
        {
                int i;
                for (i = optind; i < argc; ++i)
                printf ("Argument: %s\n", argv[i]);
        }


        return 0;
}






getopt的用法与optarg


getopt被用来解析命令行选项参数。就不用自己写东东处理argv了。
#include <unistd.h>
extern char *optarg;  //选项的参数指针
extern int optind,   //下一次调用getopt的时,从optind存储的位置处重新开始检查选项。 
extern int opterr,  //当opterr=0时,getopt不向stderr输出错误信息。
extern int optopt;  //当命令行选项字符不包括在optstring中或者选项缺少必要的参数时,该选项存储在optopt中,getopt返回'?’、
int getopt(int argc, char * const argv[], const char *optstring);
调用一次,返回一个选项。 在命令行选项参数再也检查不到optstring中包含的选项时,返回-1,同时optind储存第一个不包含选项的命令行参数。
首先说一下什么是选项,什么是参数。
字符串optstring可以下列元素,
1.单个字符,表示选项,
2.单个字符后接一个冒号:表示该选项后必须跟一个参数。参数紧跟在选项后或者以空格隔开。该参数的指针赋给optarg。
3 单个字符后跟两个冒号,表示该选项后必须跟一个参数。参数必须紧跟在选项后不能以空格隔开。该参数的指针赋给optarg。(这个特性是GNU的扩张)。
getopt处理以'-’开头的命令行参数,如optstring="ab:c::d::",命令行为getopt.exe -a -b host -ckeke -d haha 
在这个命令行参数中,-a和-h就是选项元素,去掉'-',a,b,c就是选项。host是b的参数,keke是c的参数。但haha并不是d的参数,因为它们中间有空格隔开。
还要注意的是默认情况下getopt会重新排列命令行参数的顺序,所以到最后所有不包含选项的命令行参数都排到最后。
如getopt.exe -a ima -b host -ckeke -d haha, 都最后命令行参数的顺序是: -a -b host -ckeke -d ima haha
如果optstring中的字符串以'+'加号开头或者环境变量POSIXLY_CORRE被设置。那么一遇到不包含选项的命令行参数,getopt就会停止,返回-1。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char **argv)
{
int result;
    opterr = 0;  //使getopt不行stderr输出错误信息
    while( (result = getopt(argc, argv, "ab:c::")) != -1 )
{
switch(result)
{
case 'a':
printf("option=a, optopt=%c, optarg=%s\n", optopt, optarg);
break;
case 'b':
printf("option=b, optopt=%c, optarg=%s\n", optopt, optarg);
break;
case 'c':
printf("option=c, optopt=%c, optarg=%s\n", optopt, optarg);
break;
case '?':
printf("result=?, optopt=%c, optarg=%s\n", optopt, optarg);
break;
default:
printf("default, result=%c\n",result);
break;
}
printf("argv[%d]=%s\n", optind, argv[optind]);
}
printf("result=-1, optind=%d\n", optind);   //看看最后optind的位置
    for(result = optind; result < argc; result++)
printf("-----argv[%d]=%s\n", result, argv[result]);
 //看看最后的命令行参数,看顺序是否改变了哈。
for(result = 1; result < argc; result++)
printf("\nat the end-----argv[%d]=%s\n", result, argv[result]);
return 0;
}


unistd里有个 optind 变量,每次getopt后,这个索引指向argv里当前分析的字符串的下一个索引,因此
argv[optind]就能得到下个字符串,通过判断是否以 '-'开头就可。下面是个测试程序
#include <stdio.h>
#include <unistd.h>
int main(int argc, char* argv[])
{
int tmp = 4;


while( (tmp = getopt(argc, argv, "abck")) != -1  )
{


printf("-%c\t", tmp);
int opt = optind ;
while( opt < argc )
{
if ( argv[opt][0] != '-' )
{
printf("%s\t", argv[opt]);
opt ++;
}
else
break;
}
printf("\n");
}
getchar();
}














函数说明  getopt()用来分析命令行参数。参数argc和argv是由main()传递的参数个数和内容。参数optstring 则代表欲处理的选项字符串。此函数会返回在argv 中下一个的选项字母,此字母会对应参数optstring 中的字母。如果选项字符串里的字母后接着冒号“:”,则表示还有相关的参数,全域变量optarg 即会指向此额外参数。如果getopt()找不到符合的参数则会印出错信息,并将全域变量optopt设为“?”字符,如果不希望getopt()印出错 信息,则只要将全域变量opterr设为0即可。


返回值  如果找到符合的参数则返回此参数字母,如果参数不包含在参数optstring 的选项字母则返回“?”字符,分析结束则返回-1。


范例  #include<stdio.h>
#include<unistd.h>
int main(int argc,char **argv)
{
int ch;
opterr = 0;
while((ch = getopt(argc,argv,”a:bcde”))!= -1)
switch(ch)
{
case ‘a’:
printf(“option a:’%s’\n”,optarg);
break;
case ‘b’:
printf(“option b :b\n”);
break;
default:
printf(“other option :%c\n”,ch);
}
printf(“optopt +%c\n”,optopt);
}


执行  $./getopt –b
option b:b
$./getopt –c
other option:c
$./getopt –a
other option :?
$./getopt –a12345
option a:’12345’

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/383361.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

GitHub相关

git是一个版本控制工具. 主要解决三个问题 代码被喵星人吃掉了.产品经理反复修改需求, 需要同时维护多个版本代码.多人协同开发. 安装 git for windows 这个是一个git的windows系统的命令行版本 https://git-scm.com/downloads 下载会很慢很慢 使用 Github 创建项目 注册…

linux中bin与sbin目录的作用及区别介绍

在linux系统中&#xff0c;有两个重要的目录&#xff1a;bin与sbin&#xff0c;分别包括/bin、/usr/bin/与/sbin、/usr/sbin/。 bin: bin为binary的简写&#xff0c;主要放置系统的必备执行文件&#xff0c;例如: cat、cp、chmod df、dmesg、gzip、kill、ls、mkdir、more、m…

c++起始(名词修饰,extern “C” ,引用)

名字修饰(name Mangling) 在C/C中&#xff0c;一个程序要运行起来&#xff0c;需要经历以下几个阶段&#xff1a;预处理、编译、汇编、链接。 Name Mangling是一种在编译过程中&#xff0c;将函数、变量的名称重新改编的机制&#xff0c;简单来说就是编译器为了区分各 个函数…

Linux进程间通信方式--本地socket

先上一个代码 服务端&#xff1a; [cpp] view plaincopy //s_unix.c #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #define UNIX_DOMAIN "/tmp/UNIX.domain" int main(void) { so…

extern和static的区别

c语言中的 static&#xff1a; 修饰局部变量&#xff1a;存放在静态数据区&#xff0c;生命周期位整个程序结束&#xff0c;但作用于仍为函数局部。 修饰全局变量&#xff1a;无法被同一工程其他源文件访问。 修饰函数&#xff1a;与全局变量类似。 extern&#xff1a; 可被…

RT5350原厂SDK及AP移植步骤详解

最近想搞一下rt5350&#xff0c;所以找了个原厂的SDK包进行了编译&#xff0c;很快路由器就可以用了&#xff0c;把我的编译操作步骤写了下分享给更多的爱好者&#xff0c;供大家参靠&#xff0c;下一步准备移植摄像头玩玩。有兴趣的可以一起交流。 RT5350移植Toolchain工具的安…

linux系统编程之进程概念(操作系统---管理,进程创建,进程状态,进程优先级, 环境变量,程序地址空间,进程O(1)调度方法)

系统编程&#xff1a; 进程概念->进程控制->基础IO->进程间通信->进程信号->多线程进程概念 冯诺依曼体系结构----现代计算机硬件体系结构 冯诺依曼体系结构----现代计算机硬件体系结构 计算机五大硬件单元&#xff1a;输入设备&#xff1a;键盘输出设备&#…

Make Menuconfig详解 (配置内核选择)

Make Menuconfig简介 make menuconfig 图形化的内核配置make mrproper -----删除不必要的文件和目录. #make config&#xff08;基于文本的最为传统的配置界面&#xff0c;不推荐使用&#xff09; #make menuconfig&#xff08;基于文本选单的配置界面&#xff0c;字符终端下…

Linux系统编程之进程控制(进程创建,fork函数,进程中止,进程等待,程序替换)

进程创建 fork()------复制&#xff0c;返回值&#xff0c;写时复制 vfork()创建子进程—子进程与父进程共用同一块虚拟地址空间&#xff0c; 为了防止调用栈混乱&#xff0c;因此阻塞父进程直到子进程调用exit&#xff08;&#xff09;退出或者进行程序替换 vfork创建的子…

Linux内核配置系统浅析

随着 Linux 操作系统的广泛应用&#xff0c;特别是 Linux 在嵌入式领域的发展&#xff0c;越来越多的人开始投身到 Linux 内核级的开发中。面对日益庞大的 Linux 内核源代码&#xff0c;开发者在完成自己的内核代码后&#xff0c;都将面临着同样的问题&#xff0c;即如何将源代…

Linux系统编程下做一个简易的shell

自主实现一个shell--------minshell shell&#xff1a;命令行解释器-------解释执行用户的输入&#xff08;完成相对应的功能&#xff09; 步骤 1. 获取标准输入中的字符串 2. 对字符串进行解析[ls -l -a][ls ] [-l ] [-a] 3. 创建子进程 4. 子进程中进行程序替换 5. 父进程…

C++起始(内联函数,宏的优缺点,const关键字,auto关键字(C++11)基于范围的for循环(C++11). 指针空值nullptr(C++11))

内联函数 概念 以inline修饰的函数叫做内联函数&#xff0c;编译时C编译器会在调用内联函数的地方展开&#xff0c;没有函数压栈的开销&#xff0c; 内联函数提升程序运行的效率 函数前增加inline关键字将其改成内联函数&#xff0c;在编译期间编译器会用函数体替换函数的调用…

linux内核中的汇编语言

在Linux内核代码中&#xff0c;有一部分是用汇编语言编写的。其大部分是关于中断与异常处理的底层程序&#xff0c;还有就是与初始化有关的程序&#xff0c;以及一些核心代码中调用的公用子程序。 用汇编语言编写内核代码中的部分代码&#xff0c;大体上是出于如下几个方面考虑…

数据结构课程设计---c语言实现通讯录(动态扩容+文件存储)

1 题目一 &#xff1a; 通讯录 1.1问题描述 编写一个通讯录管理系统&#xff0c;以把所学数据结构知识应用到实际软件开发中去。每条信息至包含 &#xff1a;姓名&#xff08;NAME &#xff09;街道&#xff08;STREET&#xff09;城市&#xff08;CITY&#xff09;邮编&#…

linux内核panic

1. Linux Kernel Panic的产生的原因 panic是英文中是惊慌的意思&#xff0c;Linux Kernel panic正如其名&#xff0c;linux kernel不知道如何走了&#xff0c;它会尽可能把它此时能获取的全部信息都打印出来。 有两种主要类型kernel panic&#xff0c;后面会对这两类panic做详细…

数据结构课程设计------c实现散列表(二次探测再哈希)电话簿(文件存储)

题目二 &#xff1a;散列表的设计与实现 2.1问题描述 设计散列表实现电话号码查找系统&#xff0c;使得平均查找长度不超过2基本要求 &#xff08;1&#xff09;设每个记录有下列数据项&#xff1a;电话号码、用户名、地址&#xff1b; &#xff08;2&#xff09;从键盘输入各…

科技论文----论搜索引擎现状及发展趋势

搜索引擎现状及发展趋势 【摘要】 随着最近10年中国互联网的快速发展菜互联网已经彻底改变了人们的生活方式&#xff0c;而在互联网的发展过程中。搜索引擎发挥了巨大的推动作用。本文对搜索引擎的发展历史采用的技术&#xff0c;发展现状出现的问题以及未来发展方向进行了综述…

inittab文件格式

/etc/inittab文件是Linux系统第一个进程init的配置文件。其每个记录占一行&#xff0c;每行最多512个字符。该文件的每个记录的格式为&#xff1a; id:runlevel:action:process 其中&#xff0c;id是一个不超过4个字符的标识&#xff0c;用来唯一标识一条记录。runlevel表明该条…

数据结构课程设计------扫雷游戏(升级版,可展开)

本程序由团队中的一个人所写&#xff0c;本人看懂并写下此文章 题目&#xff1a;扫雷 3.1问题描述 扫雷游戏 [基本要求] &#xff08;1&#xff09;完成棋盘的初始化并在标准显示器中显示 &#xff08;2&#xff09;通过输入行列值确定用户输入 &#xff08;3&#xff09;游…

C语言的编译链接过程的介绍

发布时间: 2012-11-08 10:17 作者: 未知 来源: 51Testing软件测试网采编 字体: 小 中 大 | 上一篇 下一篇 | 打印 | 我要投稿 | 推荐标签&#xff1a; DotNet 软件开发 | 感言十年 C语言的编译链接过程要把我们编写的一个c程序&#xff08;源代码&#x…