C++（133）
传智扫地僧课程学习笔记。
函数对象，一元谓词，这些才听，觉得有点陌生，
函数对象：
重载函数调用操作符的类，其对象常称为函数对象（functionobject），即它们是行为类似函数的对象。一个类对象，表现出一个函数的特征，就是通过“对象名+()”的方式使用一个类对象，如果没有上下文，完全可以把它看作一个函数对待。
这是通过类的operator()来实现的。
“在标准库中，函数对象被广泛地使用以获得弹性”，标准库中的很多算法都可以使用函数对象或者函数来作为自定的回调行为；
一元函数对象：函数参数1个；
二元函数对象：函数参数2个；
一元谓词函数参数1个，函数返回值是bool类型，可以作为一个判断式
&&&&&&&&&&&&&&&&&&&&&&&&&&& 谓词可以使一个仿函数，也可以是一个回调函数。
二元谓词函数参数2个，函数返回值是bool类型
一元谓词函数举例如下
1，判断给出的string对象的长度是否小于6
bool GT6(const string &s)
return s.size()&= 6;
2,判断给出的int是否在3到8之间
bool Compare( int i )
return ( i &=3 && i &= 8 );
二元谓词举例如下
1，比较两个string对象，返回一个bool值，指出第一个string是否比第二个短
bool isShorter(const string &s1, conststring &s2)
return s1.size()& s2.size();
template&typename T&
class IsDiv
IsDiv(const T &divisor)
this-&divisor =
bool operator()(T
return (t%divisor == 0);
protected:
void main03()
vector&int& v2;
for (int i=10; i&33; i++)
v2.push_back(i);
int a = 4;
IsDiv&int& myDiv(a);
//find_if(v2.begin(), v2.end(), myDiv );
template&class _InIt,
class _Pr& inline
_InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
{ // find first satisfying _Pred
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Pred);
return (_Rechecked(_First,
_Find_if(_Unchecked(_First), _Unchecked(_Last), _Pred)));
//find_if返回值是一个迭代器
//要点: 分清楚 stl算法返回的值是迭代器 还是 谓词（函数对象） 是stl算法入门的重要点
vector&int&::
it = find_if(v2.begin(), v2.end(), IsDiv&int&(a) );
if (it == v2.end())
cout && &容器中没有被4整除的元素& &&
cout &&&第一个是被4整除的元素是:& && *it &&
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：49694次
积分：3107
积分：3107
排名：第10505名
转载：237篇
译文：227篇
评论：31条
(6)(12)(9)(18)(17)(178)(10)(2)(8)(52)(7)(24)(98)(31)你正在使用的浏览器版本过低，将不能正常浏览和使用知乎。15729人阅读
linux kernel（93）
利用工作之便，今天研究了kernel下cmdline参数解析过程，记录在此，与大家共享，转载请注明出处，谢谢。Kernel 版本号：3.4.55Kernel启动时会解析cmdline，然后根据这些参数如console root来进行配置运行。Cmdline是由bootloader传给kernel，如uboot，将需要传给kernel的参数做成一个tags链表放在ram中，将首地址传给kernel，kernel解析tags来获取cmdline等信息。Uboot传参给kernel以及kernel如何解析tags可以看我的另一篇博文，链接如下：http://blog.csdn.net/skyflying2012/article/details/今天要分析的是kernel在获取到cmdline之后如何对cmdline进行解析。依据我的思路（时间顺序，如何开始，如何结束），首先看kernel下2种参数的注册。第一种是kernel通用参数，如console=ttyS0,115200 &root=/rdinit/init等。这里以console为例。第二种是kernel下各个driver中需要的参数，在写driver中，如果需要一些启动时可变参数。可以在driver最后加入module_param（）来注册一个参数，kernel启动时由cmdline指定该参数的值。这里以drivers/usb/gadget/serial.c中的use_acm参数为例（这个例子有点偏。。因为最近在调试usb虚拟串口）一 kernel通用参数对于这类通用参数，kernel留出单独一块data段，叫.ini.setup段。在arch/arm/kernel/vmlinux.lds中：.init.data : {
*(.init.data) *(.cpuinit.data) *(.meminit.data) *(.init.rodata) *(.cpuinit.rodata) *(.meminit.rodata) . = ALIGN(32); __dtb_star
. = ALIGN(16); __setup_start = .; *(.init.setup) __setup_end = .;
__initcall_start = .; *(.initcallearly.init) __initcall0_start = .; *(.initcall0.init) *(.initcall0s.init) __initcall1_start =
__con_initcall_start = .; *(.con_initcall.init) __con_initcall_end = .;
__security_initcall_start = .; *(.security_initcall.init) __security_initcall_end = .;
. = ALIGN(4); __initramfs_start = .; *(.init.ramfs) . = ALIGN(8); *(.)
}可以看到段起始和结束。.init.setup段中存放的就是通用参数和对应处理函数的映射表。在中struct obs_kernel_param {
const char *
int (*setup_func)(char *);
* Only for really core code.
See moduleparam.h for the normal way.
* Force the alignment so the compiler doesn't space elements of the
* obs_kernel_param &array& too far apart in .init.setup.
#define __setup_param(str, unique_id, fn, early)
static const char __setup_str_##unique_id[] __initconst \
__aligned(1) = \
static struct obs_kernel_param __setup_##unique_id
__used __section(.init.setup)
__attribute__((aligned((sizeof(long)))))
= { __setup_str_##unique_id, fn, early }
#define __setup(str, fn)
__setup_param(str, fn, fn, 0)
/* NOTE: fn is as per module_param, not __setup!
Emits warning if fn
* returns non-zero. */
#define early_param(str, fn)
__setup_param(str, fn, fn, 1)可以看出宏定义以及定义了结构体，该结构体存放参数和对应处理函数，存放在段中。可以想象，如果多个文件中调用该宏定义，在链接时就会根据链接顺序将定义的放到段中。以为例，在中，如下：static int __init console_setup(char *str)
__setup(&console=&, console_setup);__setup宏定义展开，如下：Static struct obs_kernel_param __setup_console_setup
__used_section(.init.setup) __attribute__((aligned((sizeof(long)))) = {
.name = “console=”,
.setup_func = console_setup,
.early = 0
}__setup_console_setup编译时就会链接到段中，运行时就会根据中的参数名与段中的对比。匹配则调用来解析该参数，的参数就是中的值，这是后面参数解析的大体过程了。&二&自定义参数对于自定义参数，留出段一部分，叫段，在中，如下：__param : AT(ADDR(__param) - 0) { __start___param = .; *(__param) __stop___param = .; }该段放在段中。那该段中存放的是什么样的数据呢？Driver中使用来注册参数，跟踪这个宏定义，最终就会找到对段的操作函数如下：/* This is the fundamental function for registering boot/module
parameters. */
#define __module_param_call(prefix, name, ops, arg, perm, level)
/* Default value instead of permissions? */
static int __param_perm_check_##name __attribute__((unused)) =
BUILD_BUG_ON_ZERO((perm) & 0 || (perm) & 0777 || ((perm) & 2))
+ BUILD_BUG_ON_ZERO(sizeof(&&prefix) & MAX_PARAM_PREFIX_LEN);
static const char __param_str_##name[] = prefix #
static struct kernel_param __moduleparam_const __param_##name
__attribute__ ((unused,__section__ (&__param&),aligned(sizeof(void *)))) \
= { __param_str_##name, ops, perm, level, { arg } }
#define module_param(name, type, perm)
module_param_named(name, name, type, perm)
#define module_param_named(name, value, type, perm)
param_check_##type(name, &(value));
module_param_cb(name, ?m_ops_##type, &value, perm);
__MODULE_PARM_TYPE(name, #type)
#define module_param_cb(name, ops, arg, perm)
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1）以中的为例，如下：static bool use_acm =
module_param(use_acm, bool, 0);Module_param展开到，如下：Static bool use_acm =
Param_check_bool(use_acm, &(use_acm));
__module_param_call(MODULE_PARAM_PREFIX, use_acm, ?m_ops_bool, &(use_acm, 0, -1));
__MODULE_PARAM_TYPE(use_acm, bool);将展开，可以看到是定义了结构体，如下：Static struct kernel_param __moduleparam_const __param_use_acm
__attribute__ ((unused,__section__ (&__param&),aligned(sizeof(void *)))) = {
.name = MODULE_PARAM_PREFIX#use_acm,
.ops = ?m_ops_bool,
.level = -1.
.arg = &use_acm
}很清楚，跟段一样，链接时会根据链接顺序将定义的放在段中。Kernel_param有个成员变量需要注意：（1）ops=param_ops_bool，是结构体，定义如下：struct kernel_param_ops param_ops_bool = {
.set = param_set_bool,
.get = param_get_bool,
};这个成员函数分别去设置和获取参数值在中可以看到默认支持的driver参数类型有（字符串）&（字符串指针）等。对于默认支持的参数类型，中提供了来处理相应类型的参数。（）Arg&=&&use_acm，宏定义展开，可以看到中存放的地址。参数设置函数（）将值设置到地址上，也就是改变了的值，从而到达传递参数的目的。(3).name=MODULE_PARAM_PREFIX#use_acm,定义了该的。MODULE_PARAM_PREFIX非常重要，定义在中：* You can override this manually, but generally this should match the
module name. */
#ifdef MODULE
#define MODULE_PARAM_PREFIX /* empty */
#define MODULE_PARAM_PREFIX KBUILD_MODNAME &.&
#endif如果我们是模块编译（make modules），则为。在模块传参时，参数名为use_acm，如insmod g_serial.ko use_acm=0正常编译，为模块名”.”如果我们在传参时不知道自己的模块名是什么，可以在自己的驱动中加打印，将MODULE_PARAM_PREFIX打印出来，来确定自己驱动的模块名。所以这里将编入，根据，如下：g_serial-y
:= serial.o
obj-$(CONFIG_USB_G_SERIAL)
+= g_serial.o最终是生成，模块名为。。kernel传参时，该参数名为g_serial.use_acm这样处理防止下众多中出现重名的参数。&可以看出，对于注册的参数，如果是默认支持类型，会提供参数处理函数。如果不是支持参数类型，则需要自己去实现了。这个可以看中的参数的注册（又有点偏。。。无意间找到的）。&参数注册是在编译链接时完成的（链接器将定义结构体放到或中）接下来需要分析启动时如何对传入的进行分析。三 kernel对cmdline的解析根据我之前写的博文可知，中中解析获取，拷贝到中。我们接着往下看。调用，将拷贝份，放在。下面调用如下：void __init parse_early_options(char *cmdline)
parse_args(&early options&, cmdline, NULL, 0, 0, 0, do_early_param);
/* Arch code calls this early on, or if not, just before other parsing. */
void __init parse_early_param(void)
static __initdata int done = 0;
static __initdata char tmp_cmdline[COMMAND_LINE_SIZE];
/* All fall through to do_early_param. */
strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
parse_early_options(tmp_cmdline);
Parse_early_param拷贝cmdline到tmp_cmdline中一份，最终调用parse_args，如下：
/* Args looks like &foo=bar,bar2 baz=fuz wiz&. */
int parse_args(const char *name,
char *args,
const struct kernel_param *params,
unsigned num,
s16 min_level,
s16 max_level,
int (*unknown)(char *param, char *val))
char *param, *
pr_debug(&Parsing ARGS: %s\n&, args);
/* Chew leading spaces */
args = skip_spaces(args);
while (*args) {
int irq_was_
args = next_arg(args, ?m, &val);
irq_was_disabled = irqs_disabled();
ret = parse_one(param, val, params, num,
min_level, max_level, unknown);
if (irq_was_disabled && !irqs_disabled()) {
printk(KERN_WARNING &parse_args(): option '%s' enabled &
&irq's!\n&, param);
switch (ret) {
case -ENOENT:
printk(KERN_ERR &%s: Unknown parameter `%s'\n&,
name, param);
case -ENOSPC:
printk(KERN_ERR
&%s: `%s' too large for parameter `%s'\n&,
name, val ?: &&, param);
printk(KERN_ERR
&%s: `%s' invalid for parameter `%s'\n&,
name, val ?: &&, param);
/* All parsed OK. */
void __init parse_early_options(char *cmdline)
parse_args(&early options&, cmdline, NULL, 0, 0, 0, do_early_param);
}Parse_args遍历，按照空格切割获取参数，对所有参数调用获取参数名和参数值。如，则，。调用。如下：static int parse_one(char *param,
char *val,
const struct kernel_param *params,
unsigned num_params,
s16 min_level,
s16 max_level,
int (*handle_unknown)(char *param, char *val))
/* Find parameter */
for (i = 0; i & num_ i++) {
if (parameq(param, params[i].name)) {
if (params[i].level & min_level
|| params[i].level & max_level)
/* No one handled NULL, so do it here. */
if (!val && params[i].ops-&set != param_set_bool
&& params[i].ops-&set != param_set_bint)
return -EINVAL;
pr_debug(&They are equal!
Calling %p\n&,
params[i].ops-&set);
mutex_lock(?m_lock);
err = params[i].ops-&set(val, ?ms[i]);
mutex_unlock(?m_lock);
if (handle_unknown) {
pr_debug(&Unknown argument: calling %p\n&, handle_unknown);
return handle_unknown(param, val);
pr_debug(&Unknown argument `%s'\n&, param);
return -ENOENT;
}由于从传入的，所以是直接走的最后函数。该函数是由传入的。如下：static int __init do_early_param(char *param, char *val)
const struct obs_kernel_param *p;
for (p = __setup_ p & __setup_ p++) {
if ((p-&early && parameq(param, p-&str)) ||
(strcmp(param, &console&) == 0 &&
strcmp(p-&str, &earlycon&) == 0)
if (p-&setup_func(val) != 0)
printk(KERN_WARNING
&Malformed early option '%s'\n&, param);
/* We accept everything at this stage. */
}Do_early_param遍历段，如果有的为，或中有参数并且有参数，则会调用该的函数来解析参数。Do_early_param会对中优先级较高的参数进行解析。我翻了下源码找到一个例子，就是，利用参数来注册最早的一个，有兴趣大家可以参考下。如果想启动中尽早打印输出，方便调试，可以注册为的。在其参数处理函数中，注册一个早期的，从而是信息正常打印，这个在后面我还会总结一篇打印机制来说这个问题。是为中需要尽早配置的功能（如）做的解析。Do_early_param就说道这里，该函数并没有处理我们经常使用的通用参数和自定义参数。接着往下看。代码如下：
setup_arch(&command_line);
mm_init_owner(&init_mm, &init_task);
mm_init_cpumask(&init_mm);
setup_command_line(command_line);
setup_nr_cpu_ids();
setup_per_cpu_areas();
smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
build_all_zonelists(NULL);
page_alloc_init();
printk(KERN_NOTICE &Kernel command line: %s\n&, boot_command_line);
parse_early_param();
parse_args(&Booting kernel&, static_command_line, __start___param,
__stop___param - __start___param,
-1, -1, &unknown_bootoption);Parse_early_param结束后，调用了。这次调用，不像中调用那样指针都为，而是指定了段。回到上面看函数，参数为段起始地址，为个数。Min_level,max_level都为Parse_args还是像之前那样，遍历，分割获取每个参数的和，对每个参数调用。回看函数源码：（）首先会遍历段中所有将其与参数的对比，同名则调用该成员变量的方法来设置参数值。联想前面讲自定义参数例子中有参数，则在中遍历匹配在中注册的，调用的函数，从而设置（2）如果传给是通用参数，如。则前面遍历段不会找到匹配的。就走到后面调用。就是传来的，代码如下：&/*
* Unknown boot options get handed to init, unless they look like
* unused parameters (modprobe will find them in /proc/cmdline).
static int __init unknown_bootoption(char *param, char *val)
repair_env_string(param, val);
/* Handle obsolete-style parameters */
if (obsolete_checksetup(param))
/* Unused module parameter. */
if (strchr(param, '.') && (!val || strchr(param, '.') & val))
if (panic_later)
if (val) {
/* Environment option */
for (i = 0; envp_init[i]; i++) {
if (i == MAX_INIT_ENVS) {
panic_later = &Too many boot env vars at `%s'&;
panic_param =
if (!strncmp(param, envp_init[i], val - param))
envp_init[i] =
} else {&/span&&span style=&font-size:14&&
/* Command line option */
for (i = 0; argv_init[i]; i++) {
if (i == MAX_INIT_ARGS) {
panic_later = &Too many boot init vars at `%s'&;
panic_param =
argv_init[i] =
}首先会将重新组合为形式。Obsolete_checksetup则遍历段所有，如有与匹配，则调用进行参数值配置。这里需要注意的一点是将重新拼成了形式。后面遍历匹配都是匹配的而不是。如之前分析通用参数所举例子，。Console=ttyS0，是匹配前面，如果匹配，则跳过，获取到其值，调用其具体的函数来解析设置参数值。可以想象，对于传来的每一个参数都会将以及段遍历匹配，匹配到或一致，则调用其相应的或函数进行参数值解析或设置。Start_kernel中结束，的就解析完成！&总结下的参数解析：（）编译链接，利用段将所需参数（driver及通用）和对应处理函数的映射表（结构体）存放起来。（）启动，处理早期使用的参数（如）（3）对每个参数都遍历进行匹配，匹配成功，则调用对应处理函数进行参数值的解析和设置。还有一点很值得思考，kernel下对于这种映射处理函数表方式还有很多使用。比如之前博文中uboot传参给kernel，kernel对于不同tags的处理函数也是以该种方式来映射的。kernel下driver私有结构体的回调处理函数也有这个思想哇！
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1092794次
积分：9867
积分：9867
排名：第1659名
原创：131篇
转载：95篇
评论：297条
阅读：19599
阅读：50960
阅读：102168
(1)(1)(1)(1)(3)(2)(1)(1)(1)(2)(2)(3)(2)(1)(1)(4)(2)(1)(1)(4)(5)(2)(6)(2)(7)(7)(3)(10)(1)(2)(7)(3)(1)(7)(13)(13)(6)(7)(9)(10)(13)(11)(12)(7)(8)(17)(2)君，已阅读到文档的结尾了呢~~
acm常用函数 vlookup函数的运用 if函数的运用 淄博到济南的火车 成都到重庆的动车 函数运用 excell函数运用 济南到青岛的火车 你看不到的天空 到另一个你的身边去
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
ACM运用到的函数
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口一元函数对象：函数参数1个；
二元函数对象：函数参数2个；
一元谓词 函数参数1个，函数返回值是bool类型，可以作为一个判断式
谓词可以使一个仿函数，也可以是一个回调函数。
demo 一元谓词
#include &iostream&
#include &cstdio&
#include &vector&
#include &algorithm&
template &typename T&
class IsDiv
IsDiv(const T d)
bool operator()(T &t) // 一元谓词
return (t % divisor == 0);
protected:
void play01()
vector&int&
for (int i = 10; i & 25; ++i) {
v.push_back(i);
int a = 4;
IsDiv&int& isDiv(a);
find_if(v.begin(), v.end(), isDiv);
//find_if(v.begin(), v.end(), IsDiv&int&(4)); // 也可以这样写
/* find_if()函数原型
template&class _InIt,
class _Pr& inline
_InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
{ // find first satisfying _Pred
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Pred);
return (_Rechecked(_First,
_Find_if(_Unchecked(_First), _Unchecked(_Last), _Pred)));
// find_if的返回值值一个迭代器
vector&int&::iterator it = find_if(v.begin(), v.end(), isDiv);
if (it == v.end()) {
cout && &fail\n&;
cout && &success & && *it &&
int main()
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：254720次
积分：6550
积分：6550
排名：第3430名
原创：400篇
转载：31篇
译文：10篇
评论：39条
文章：12篇
阅读：12996
(1)(2)(4)(1)(1)(6)(32)(2)(3)(3)(18)(79)(92)(194)