-
2019-07-04 21:05:10
构造函数、析构函数是怎么回事呢
构造函数和析构函数什么时候执行,怎么执行
因为类的数据成员不能在类声明的时候初始化,所以需要构造函数来实现某些成员函数的初始化。下面定义的变量需要通过构造函数Line中的参数进行初始化,当用Line创建一个类对象时自动执行。
class Line { public: Line(double len); // 这是构造函数声明 void getLength(); ~Line(); // 这是析构函数声明 private: double length; };
构造函数名称和类名相同,析构函数的名称为“~类名”。
成员函数定义: Line::Line(double len)//构造函数定义 { length=len; cout << "Object is being created" << endl; } Line::~Line()//析构函数定义 { cout << "Object is being deleted" << endl; } void Line::getLength() { cout<<"the length of the line is"<<length<<endl; }
在创建类的对象时,自动执行构造函数,并对类中的变量传参,进行初始化。在主函数return 0时,自动执行析构函数。
int main( ) { int i=0;cout<<i<<endl; //cout<<i<<endl,用这一句代码来看构造函数和析构函数什么时候运行 Line line(10.9);i++;cout<<i<<endl; line.getLength();//此时并未执行析构函数,从运行结果可以看出↓ i++;cout<<i<<endl; return 0; }
执行结果是
0 Object is being created 1 the length of the line is10.9 2 Object is being deleted
可以看出, 当运行Line line;时,构造函数自动执行;而直到return 0;析构函数才自动执行。
带参数的构造函数和不带参数的构造函数
构造函数可以是带参数的,也可以是不带参数的,都可以实现类中变量的初始化,给大家看一下区别
class Student{ private: char *m_name; int m_age; float m_score; public: Student();//这是不带参数的构造函数 Student(char *name, int age, float score);//这是带了三个不同类型参数的构造函数 void show(); }; Student::Student(){ //这是不带参数的构造函数的变量初始化过程; m_name = NULL; m_age = 0; m_score = 0.0; } Student::Student(char *name, int age, float score){ //这是带参数的构造函数的变量初始化过程; m_name = name; m_age = age; m_score = score; } void Student::show(){ if(m_name == NULL || m_age <= 0){ cout<<"成员变量还未初始化"<<endl; } else{cout<<m_name<<"的年龄是"<<m_age<<",成绩是"<<m_score<<endl; } } int main(){ //调用构造函数 Student() Student stud;//创建一个不带参数的对象 stud.show(); Student stu("小明", 15, 92.5f);//创建一个带参数的对象 stu.show(); return 0; }
以上代码的运行结果是
成员变量还未初始化 小明的年龄是15,成绩是92.5
通过以上程序段可以看出,如果创建一个不带参数的类对象,会自动执行不带参数的构造函数,如果程序员没有定义构造函数,则系统有一个默认构造函数可以执行。创建一个带有参数的类对象,则自动执行参数数量和类型相匹配的构造函数。
更多相关内容 -
python定义函数时默认参数注意事项
2020-12-14 07:11:38如果在调用一个函数时,没有传递默认参数,则函数内的默认参数是对函数的默认参数属性__defaults__的引用,如def func(arg1=[]): arg1.append(2)调用func时如果没有传参,上面的arg1就是func.__defaults__[0]的引用没...如果在调用一个函数时,没有传递默认参数,则函数内的默认参数是对函数的默认参数属性__defaults__的引用,
如
def func(arg1=[]): arg1.append(2)
调用func时如果没有传参,上面的arg1就是func.__defaults__[0]的引用
没传递默认参数,会发生以下情况
由于func.__defaults__[0]是可变类型,导致每一次调用func,arg1都会对func.__defaults__[0]进行操作(func.__defaults__[0].append(2),
这样在有些情况下会导致逻辑出错的,例如
def func(arg1=[]): if(arg1==[]): print'arg1 is empty' arg1.append(1) else: print'arg1 is not empty'print arg1 func() # arg1 is empty
func() #arg1 is not empty [1]
第二次调用func的时候,并没有传递参数arg1,但是第一次调用时,函数内部已经修改了__defaults__
这是为啥呢?为何第二次调用不重置arg1为[]?
因为
Python的默认参数只会在函数定义时被确定,而不是每次调用时重新确定,所以,一旦在函数中修改了默认参数,则再随后的调用中都会生效
由于有这个特性,在定义函数时,如果默认参数使用可变的对象类型,如上例子,则很可能导致逻辑出错,
所以,如不是特别需要,则不允许在函数内部对默认参数引用的func.__defaults__属性进行修改,如何能让一个对象不被修改?那就是在操作arg1前取消它对__defaults__的引用
以上例子改动一下
def func(arg1=[]): if(arg1==[]): print'arg1 is empty' arg1=[] arg1.append(1) else: print'arg1 is not empty'print arg1
上例中,在用户没有传递默认参数arg1时,函数内部会给arg1变量重新赋值,让arg1去引用我们想用的对象[],这样arg1就不会修改func.__defaults__了
如果是默认参数是有值的情况,可以这样操作
def func(arg1=[1,2,3]): if(arg1==[1,2,3]): print'is [1,2,3]' arg1=[1,2,3] #重点是这里,取消arg1对__defaults__属性的引用,防止arg1修改__defaults__ arg1.append(1) else: print'not [1,2,3]'print arg1
以上太啰嗦,下例模仿了python官方例子,使用不可变类型(例如None)作为默认参数,逻辑简洁,推荐使用
def append_to(element, to=None): #默认参数to定义时为None,但函数逻辑中进行进一步重新赋值为想使用的默认值
if to is None: to = [1,2,3] to.append(element) return to
总结:
防止默认参数修改函数的__defaults__,需要:
1.定义默认参数时,最好使用不可变类型.
2.如果默认参数一定要使用可变类型,那就在函数内部对默认参数重新赋值为可变类型的具体值.
python定义函数时的参数&;调用函数时的传参
一.定义函数: 1.位置参数:直接定义参数 2.默认参数(或者关键字参数):参数名 = "默认值" 3.位置参数必须在默认参数之前 二.调用函数: 1.按位置传,直接写参数的值 2 ...
python定义函数时的默认返回值
python定义函数时,一般都会有指定返回值,如果没有显式指定返回值,那么python就会默认返回值为None, 即隐式返回语句: return None 执行如下代码 def now(): prin ...
python中函数的默认参数陷阱问题
其实也不能说是陷阱,只是一个不容易注意到的地方,尤其是有其他java/c++类编程语言经验的人员,这里涉及到python的一个特点,所以笔者说是陷阱只是一个噱头而已. def test(item, b ...
python定义函数时,形参前加*和**的意义
转发:https://blog.csdn.net/qq_34806812/article/details/82017839 1.加*表示接受一个tuple类型(元组),如: 2.加**表示接受一个di ...
Python 中函数的 收集参数 机制
定义函数的时候,在参数前加了一个 * 号,函数可以接收零个或多个值作为参数.返回结果是一个元组. 传递零个参数时函数并不报错,而是返回一个空元组.但以上这种方法也有局限性,它不能收集关键字参数. 对关 ...
Python函数的默认参数的设计【原创】
在Python教程里,针对默认参数,给了一个“重要警告”的例子: def f(a, L=[]): L.append(a) return L print(f(1)) print(f(2)) print( ...
在python函数中默认参数的一些坑
一.默认参数 python为了简化函数的调用,提供了默认参数机制: 这样在调用pow函数时,就可以省略最后一个参数不写: 在定义有默认参数的函数时,需要注意以下: 必选参数必须在前面,默认参数在后: ...
对C++虚函数使用默认参数的注意事项
本文为大便一箩筐的原创内容,转载请注明出处,谢谢:http://www.cnblogs.com/dbylk/ 备忘一个关于虚函数的小知识点 使用多态调用一个类型中定义的虚函数时,编译器会根据指针的当前 ...
C++中函数的默认参数
使用方法: (1)在函数声明或定义时,直接对参数赋值,该参数就是默认参数. (2)在函数调用时,省略部分或全部参数,这时就会使用默认参数进行代替. 注意事项: (1)一般在声明函数是设置默认参数. 如 ...
随机推荐
重写AgileEAS.NET SOA 中间件平台账号密码的加密算法
一.平台简介 AgileEAS.NET SOA 中间件平台是一款基于基于敏捷并行开发思想和Microsoft .Net构件(组件)开发技术而构建的一个快速开发应用平台.用于帮助中小型软件企业建立一条适 ...
用Access作为后台数据库支撑。
/// /// 读取Excel文档 /// /// 文件名称&l ...
使用C# WinForm制作 员工打卡项目 -- S2 2.3
新建一个员工类,存储员工的信息 新建一个List<>集合,并在load事件中实例化三个员工对象 DataGridView绑定数据源,可以显示出数据 点击查询按钮,查询工号等同于输入的数的员 ...
[Unity3D]开发视图中的标记 - Gizmos
这个类用来做自己的组件很不错,比如下面这个图的路径点,他其实是个Empty Object,可以自己加脚本让他带上标记.官方解释还可以用来做帮助提示的-.- 大游戏场景的制作时候,你可以用这个在地图上写 ...
c#+ArcEngine中的IGroupLayer的用法
转自羊子雄起原文c#+ArcEngine中的IGroupLayer的用法 在AE开发中,我们知道axMapControl.LayerCount能获取图层的数量,但是这种方法不能获取到图层组里面的图层, ...
EDK II代码实例之Variable
EFI_STATUS Status = EFI_SUCCESS; EFI_GUID OemOSTypeGuid = {0xd06a0bc7, 0x9feb, 0x4cbb, 0xbd, 0x78, 0 ...
wpf 实现 css3 中 boxshadow inset 效果
using System; using System.Linq; using System.Windows; using System.Windows.Controls; using System.W ...
day10 参数args kwargs 作用域
函数参数/作用域/args/kwargs 1.参数 1.1参数基本知识 任意个数 任意类型 func("1",True) 1.2位置传参(调用函数并传入参数) def func(a ...
Django之模板1
Django模板 一.变量(只需要记住两种特殊符号) {{ }} 和{% %} {{ }}表示变量,在模板渲染的时候替换成值,变量名由字母数字和下划线组成. {% %}表示逻辑相关的操作. 点(.)在 ...
windows下搭建voip服务器
软件: yate-6.0.0-1-setup.exe 服务端,里面也有个客户端 eyeBeam.exe 客户端 步骤: 失败....
-
函数参数的默认值
2018-01-21 21:59:47函数参数的默认值 基本用法 ES6 之前,不能直接为函数的参数指定默认值,只能采用变通的方法。 function log(x, y) { y = y || 'World'; console.log(x, y);}log('Hello') // Hello Worldlog('Hello', 'China...函数参数的默认值
基本用法
ES6 之前,不能直接为函数的参数指定默认值,只能采用变通的方法。
function log(x, y) {
y = y || 'World';
console.log(x, y);
}
log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello World
上面代码检查函数
log
的参数y
有没有赋值,如果没有,则指定默认值为World
。这种写法的缺点在于,如果参数y
赋值了,但是对应的布尔值为false
,则该赋值不起作用。就像上面代码的最后一行,参数y
等于空字符,结果被改为默认值。为了避免这个问题,通常需要先判断一下参数
y
是否被赋值,如果没有,再等于默认值。if (typeof y === 'undefined') {
y = 'World';
}
ES6 允许为函数的参数设置默认值,即直接写在参数定义的后面。
function log(x, y = 'World') {
console.log(x, y);
}
log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello
可以看到,ES6 的写法比 ES5 简洁许多,而且非常自然。下面是另一个例子。
function Point(x = 0, y = 0) {
this.x = x;
this.y = y;
}
const p = new Point();
p // { x: 0, y: 0 }
除了简洁,ES6 的写法还有两个好处:首先,阅读代码的人,可以立刻意识到哪些参数是可以省略的,不用查看函数体或文档;其次,有利于将来的代码优化,即使未来的版本在对外接口中,彻底拿掉这个参数,也不会导致以前的代码无法运行。
参数变量是默认声明的,所以不能用
let
或const
再次声明。function foo(x = 5) {
let x = 1; // error
const x = 2; // error
}
上面代码中,参数变量
x
是默认声明的,在函数体中,不能用let
或const
再次声明,否则会报错。使用参数默认值时,函数不能有同名参数。
// 不报错
function foo(x, x, y) {
// ...
}
// 报错
function foo(x, x, y = 1) {
// ...
}
// SyntaxError: Duplicate parameter name not allowed in this context
另外,一个容易忽略的地方是,参数默认值不是传值的,而是每次都重新计算默认值表达式的值。也就是说,参数默认值是惰性求值的。
let x = 99;
function foo(p = x + 1) {
console.log(p);
}
foo() // 100
x = 100;
foo() // 101
上面代码中,参数
p
的默认值是x + 1
。这时,每次调用函数foo
,都会重新计算x + 1
,而不是默认p
等于 100。与解构赋值默认值结合使用
参数默认值可以与解构赋值的默认值,结合起来使用。
function foo({x, y = 5}) {
console.log(x, y);
}
foo({}) // undefined 5
foo({x: 1}) // 1 5
foo({x: 1, y: 2}) // 1 2
foo() // TypeError: Cannot read property 'x' of undefined
上面代码只使用了对象的解构赋值默认值,没有使用函数参数的默认值。只有当函数
foo
的参数是一个对象时,变量x
和y
才会通过解构赋值生成。如果函数foo
调用时没提供参数,变量x
和y
就不会生成,从而报错。通过提供函数参数的默认值,就可以避免这种情况。function foo({x, y = 5} = {}) {
console.log(x, y);
}
foo() // undefined 5
上面代码指定,如果没有提供参数,函数
foo
的参数默认为一个空对象。下面是另一个解构赋值默认值的例子。
function fetch(url, { body = '', method = 'GET', headers = {} }) {
console.log(method);
}
fetch('http://example.com', {})
// "GET"
fetch('http://example.com')
// 报错
上面代码中,如果函数
fetch
的第二个参数是一个对象,就可以为它的三个属性设置默认值。这种写法不能省略第二个参数,如果结合函数参数的默认值,就可以省略第二个参数。这时,就出现了双重默认值。function fetch(url, { body = '', method = 'GET', headers = {} } = {}) {
console.log(method);
}
fetch('http://example.com')
// "GET"
上面代码中,函数
fetch
没有第二个参数时,函数参数的默认值就会生效,然后才是解构赋值的默认值生效,变量method
才会取到默认值GET
。作为练习,请问下面两种写法有什么差别?
// 写法一
function m1({x = 0, y = 0} = {}) {
return [x, y];
}
// 写法二
function m2({x, y} = { x: 0, y: 0 }) {
return [x, y];
}
上面两种写法都对函数的参数设定了默认值,区别是写法一函数参数的默认值是空对象,但是设置了对象解构赋值的默认值;写法二函数参数的默认值是一个有具体属性的对象,但是没有设置对象解构赋值的默认值。
// 函数没有参数的情况
m1() // [0, 0]
m2() // [0, 0]
// x 和 y 都有值的情况
m1({x: 3, y: 8}) // [3, 8]
m2({x: 3, y: 8}) // [3, 8]
// x 有值,y 无值的情况
m1({x: 3}) // [3, 0]
m2({x: 3}) // [3, undefined]
// x 和 y 都无值的情况
m1({}) // [0, 0];
m2({}) // [undefined, undefined]
m1({z: 3}) // [0, 0]
m2({z: 3}) // [undefined, undefined]
参数默认值的位置
通常情况下,定义了默认值的参数,应该是函数的尾参数。因为这样比较容易看出来,到底省略了哪些参数。如果非尾部的参数设置默认值,实际上这个参数是没法省略的。
// 例一
function f(x = 1, y) {
return [x, y];
}
f() // [1, undefined]
f(2) // [2, undefined])
f(, 1) // 报错
f(undefined, 1) // [1, 1]
// 例二
function f(x, y = 5, z) {
return [x, y, z];
}
f() // [undefined, 5, undefined]
f(1) // [1, 5, undefined]
f(1, ,2) // 报错
f(1, undefined, 2) // [1, 5, 2]
上面代码中,有默认值的参数都不是尾参数。这时,无法只省略该参数,而不省略它后面的参数,除非显式输入
undefined
。如果传入
undefined
,将触发该参数等于默认值,null
则没有这个效果。function foo(x = 5, y = 6) {
console.log(x, y);
}
foo(undefined, null)
// 5 null
上面代码中,
x
参数对应undefined
,结果触发了默认值,y
参数等于null
,就没有触发默认值。函数的 length 属性
指定了默认值以后,函数的
length
属性,将返回没有指定默认值的参数个数。也就是说,指定了默认值后,length
属性将失真。(function (a) {}).length // 1
(function (a = 5) {}).length // 0
(function (a, b, c = 5) {}).length // 2
上面代码中,
length
属性的返回值,等于函数的参数个数减去指定了默认值的参数个数。比如,上面最后一个函数,定义了 3 个参数,其中有一个参数c
指定了默认值,因此length
属性等于3
减去1
,最后得到2
。这是因为
length
属性的含义是,该函数预期传入的参数个数。某个参数指定默认值以后,预期传入的参数个数就不包括这个参数了。同理,后文的 rest 参数也不会计入length
属性。(function(...args) {}).length // 0
如果设置了默认值的参数不是尾参数,那么
length
属性也不再计入后面的参数了。(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1
作用域
一旦设置了参数的默认值,函数进行声明初始化时,参数会形成一个单独的作用域(context)。等到初始化结束,这个作用域就会消失。这种语法行为,在不设置参数默认值时,是不会出现的。
var x = 1;
function f(x, y = x) {
console.log(y);
}
f(2) // 2
上面代码中,参数
y
的默认值等于变量x
。调用函数f
时,参数形成一个单独的作用域。在这个作用域里面,默认值变量x
指向第一个参数x
,而不是全局变量x
,所以输出是2
。再看下面的例子。
let x = 1;
function f(y = x) {
let x = 2;
console.log(y);
}
f() // 1
上面代码中,函数
f
调用时,参数y = x
形成一个单独的作用域。这个作用域里面,变量x
本身没有定义,所以指向外层的全局变量x
。函数调用时,函数体内部的局部变量x
影响不到默认值变量x
。如果此时,全局变量
x
不存在,就会报错。function f(y = x) {
let x = 2;
console.log(y);
}
f() // ReferenceError: x is not defined
下面这样写,也会报错。
var x = 1;
function foo(x = x) {
// ...
}
foo() // ReferenceError: x is not defined
上面代码中,参数
x = x
形成一个单独作用域。实际执行的是let x = x
,由于暂时性死区的原因,这行代码会报错”x 未定义“。如果参数的默认值是一个函数,该函数的作用域也遵守这个规则。请看下面的例子。
let foo = 'outer';
function bar(func = () => foo) {
let foo = 'inner';
console.log(func());
}
bar(); // outer
上面代码中,函数
bar
的参数func
的默认值是一个匿名函数,返回值为变量foo
。函数参数形成的单独作用域里面,并没有定义变量foo
,所以foo
指向外层的全局变量foo
,因此输出outer
。如果写成下面这样,就会报错。
function bar(func = () => foo) {
let foo = 'inner';
console.log(func());
}
bar() // ReferenceError: foo is not defined
上面代码中,匿名函数里面的
foo
指向函数外层,但是函数外层并没有声明变量foo
,所以就报错了。下面是一个更复杂的例子。
var x = 1;
function foo(x, y = function() { x = 2; }) {
var x = 3;
y();
console.log(x);
}
foo() // 3
x // 1
上面代码中,函数
foo
的参数形成一个单独作用域。这个作用域里面,首先声明了变量x
,然后声明了变量y
,y
的默认值是一个匿名函数。这个匿名函数内部的变量x
,指向同一个作用域的第一个参数x
。函数foo
内部又声明了一个内部变量x
,该变量与第一个参数x
由于不是同一个作用域,所以不是同一个变量,因此执行y
后,内部变量x
和外部全局变量x
的值都没变。如果将
var x = 3
的var
去除,函数foo
的内部变量x
就指向第一个参数x
,与匿名函数内部的x
是一致的,所以最后输出的就是2
,而外层的全局变量x
依然不受影响。var x = 1;
function foo(x, y = function() { x = 2; }) {
x = 3;
y();
console.log(x);
}
foo() // 2
x // 1
应用
利用参数默认值,可以指定某一个参数不得省略,如果省略就抛出一个错误。
function throwIfMissing() {
throw new Error('Missing parameter');
}
function foo(mustBeProvided = throwIfMissing()) {
return mustBeProvided;
}
foo()
// Error: Missing parameter
上面代码的
foo
函数,如果调用的时候没有参数,就会调用默认值throwIfMissing
函数,从而抛出一个错误。从上面代码还可以看到,参数
mustBeProvided
的默认值等于throwIfMissing
函数的运行结果(注意函数名throwIfMissing
之后有一对圆括号),这表明参数的默认值不是在定义时执行,而是在运行时执行。如果参数已经赋值,默认值中的函数就不会运行。另外,可以将参数默认值设为
undefined
,表明这个参数是可以省略的。function foo(optional = undefined) { ··· }
-
函数指针作为函数参数及函数作为函数参数
2018-12-02 10:47:07但是我不知道你要用哪个函数来处理这个命令, 我也不知道你的主模块是什么.cpp或者.h, 或者说, 我根本不用关心你在主模块里怎么处理它, 也不应该关心用什么函数处理它...... 怎么办? 使用回调! —— lone wolf...转载于:http://blog.csdn.net/vlily/article/details/7244682
转载于:http://blog.csdn.net/shengnan_wu/article/details/8116935
转载于:http://blog.csdn.net/callmeback/article/details/4242260/
转载于:https://blog.csdn.net/initiallysunny/article/details/53708466
C++中一个函数作为作为另一个函数的参数:
把函数名作为参数就是函数的地址了.
要将函数名作为参数,需要使用函数指针。函数指针的定义格式为
ret_type (*var_name)(arg_list);
表示返回值为ret_type,参数列表为arg_list的函数指针var_name.
如
int (*p)(int,int);
表示返回值为int,参数为两个int型的函数指针p。
以函数指针作为形参,即可实现函数名作为参数,由另一个函数调用。
一、 定义某一函数的指针类型:
就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。
我先给你一个自定义数据类型的例子。
typedef int* PINT; //为int* 类型定义了一个PINT的别名
int main()
{
int x;
PINT px=&x; //与int * px=&x;是等价的。PINT类型其实就是int * 类型
*px=10; //px就是int*类型的变量
return 0;
}
根据注释,应该不难看懂吧!(虽然你可能很少这样定义使用,但以后学习Win32编程时会经常见到的。)
下面我们来看一下函数指针类型的定义及使用:(请与上对照!)
//自行包含头文件
void MyFun(int x); //此处的申明也可写成:void MyFun( int );
typedef void (*FunType)(int ); //这样只是定义一个函数指针类型
FunType FunP; //然后用FunType类型来申明全局FunP变量
int main(int argc, char* argv[])
{
//FunType FunP; //函数指针变量当然也是可以是局部的 ,那就请在这里申明了。
MyFun(10);
FunP=&MyFun;
(*FunP)(20);
return 0;
}
void MyFun(int x)
{
printf(“%d\n”,x);
}
看黑体部分:
首先,在void (*FunType)(int ); 前加了一个typedef 。这样只是定义一个名为FunType函数指针类型,而不是一个FunType变量。
然后,FunType FunP; 这句就如PINT px;一样地申明一个FunP变量。
其它相同。整个程序完成了相同的事。
这样做法的好处是:
有了FunType类型后,我们就可以同样地、很方便地用FunType类型来申明多个同类型的函数指针变量了。如下:
FunType FunP2;
FunType FunP3;
//……
二、 函数指针作为某个函数的参数
既然函数指针变量是一个变量,当然也可以作为某个函数的参数来使用的。所以,你还应知道函数指针是如何作为某个函数的参数来传递使用的。
给你一个实例:
要求:我要设计一个CallMyFun函数,这个函数可以通过参数中的函数指针值不同来分别调用MyFun1、MyFun2、MyFun3这三个函数(注:这三个函数的定义格式应相同)。
实现:代码如下:
//自行包含头文件
void MyFun1(int x);
void MyFun2(int x);
void MyFun3(int x);
typedef void (*FunType)(int ); //②. 定义一个函数指针类型FunType,与①函数类型一至
void CallMyFun(FunType fp,int x);
int main(int argc, char* argv[])
{
CallMyFun(MyFun1,10); //⑤. 通过CallMyFun函数分别调用三个不同的函数
CallMyFun(MyFun2,20);
CallMyFun(MyFun3,30);
}
void CallMyFun(FunType fp,int x) //③. 参数fp的类型是FunType。
{
fp(x);//④. 通过fp的指针执行传递进来的函数,注意fp所指的函数是有一个参数的
}
void MyFun1(int x) // ①. 这是个有一个参数的函数,以下两个函数也相同
{
printf(“函数MyFun1中输出:%d\n”,x);
}
void MyFun2(int x)
{
printf(“函数MyFun2中输出:%d\n”,x);
}
void MyFun3(int x)
{
printf(“函数MyFun3中输出:%d\n”,x);
}
输出结果:略
-
函数指针是指向函数的指针变量。c在编译时,每一个函数都有一个入口地址,该入口地址就是函数指针指向的地址处。有了指向函数的指针变量后。可以通过该指针变量调用函数,函数指针有两个用途:调用函数、做函数的参数:
-
调用函数,如下所示:
-
输出结果如下:
由以上可以说明成功调用。
b.无参函数指针做参数的实现,如下(标准写法)所示:
输出结果如下:
还有以下写法也能成功,因为c语言标准规定可以这样用:
也能成功输出
c.带参有返回值的函数指针做参数的
输出结果如下:
而不能写成如下所示:
也可写成以下形式,其中涉及到函数指针类型的转换:
2.函数指针数组的实用之处:当我们需要判断大量条件的时候,并且在每一个条件都有相应的处理函数,这时实用switch...case..的代码量会很大,并且效率会比较低,这个时候就可以使用函数指针数组来解决这个问题了,可以使用每个条件为数组下表:如下所示:
结果如下
回调函数
1、基础知识
所谓回调,就是模块A要通过模块B的某个函数b()完成一定的功能,但是函数b()自己无法实现全部功能,需要反过头来调用模块A中的某个函数a()来完成,这个a()就是回调函数。如下图
①约定接口规范。在模块B必须约定接口规范,也就是定义回调函数a()的函数原型
一开始是不好理解,用下面这个例子可能会有帮助:
诸葛亮(A)给赵子龙(B)一个锦囊(a()),吩咐他在干活时(b())若遇到危急时打开按锦囊(a())指示办, 锦囊里的命令就是回调函数,危急时刻就是回调的时机。
不同的锦囊里可以有不同的命令。在看LWIP时,见到用回调函数,再看某老外公司OPC源代码时,见到用回调函数。看我国内某些代码(我公司软件等)时没用到。于是,我对回调函数产生了很大的好奇。以前,我写VC程序时用到过回调函数,但是没有用C语言来使用。最近,看到国外大量的经典代码中广泛使用了回调函数(LWIP、某两个公司的OPC程序等),都是C语言来实现的,而不是VC windows程序中别人实现自己使用的那种。
为了弄明白这种函数的奥妙,首先提出三个问题:
1. 回调函数是什么东西?
2. 回调函数怎么开发,怎么使用?
3. 回调函数的作用,应该在什么情况下使用?
带着问题来学习,有目的!呵呵,个人经验。
打开baidu.com、google.cn搜索了好多资料,如下:
顺便提一下,某君的一个签名很让我佩服:1好好活着,因为我们会死很久。2五千年的文明 两百年的无奈
第一个问题:
*******************************************************************************
其实回调就是一种利用函数指针进行函数调用的过程.
为什么要用回调呢?比如我要写一个子模块给你用, 来接收远程socket发来的命令.当我接收到命令后, 需要调用你的主模块的函数, 来进行相应的处理.但是我不知道你要用哪个函数来处理这个命令, 我也不知道你的主模块是什么.cpp或者.h, 或者说, 我根本不用关心你在主模块里怎么处理它, 也不应该关心用什么函数处理它...... 怎么办?
使用回调!
—— lone wolf
使用回调函数实际上就是在调用某个函数(通常是API函数)时,将自己的一个函数(这个函数为回调函数)的地址作为参数传递给那个函数。而那个函数在需要的时候,利用传递的地址调用回调函数,这时你可以利用这个机会在回调函数中处理消息或完成一定的操作。
—— 某专家
回调函数,就是由你自己写的。你需要调用另外一个函数,而这个函数的其中一个参数,就是你的这个回调函数名。这样,系统在必要的时候,就会调用你写的回调函数,这样你就可以在回调函数里完成你要做的事。
—— 绿叶
http://hi.baidu.com/zhuyipeng/blog/item/863fefdb7c736c63d1164eec.html 是一篇比较好的文章。
什么是回调函数?
回调函数是应用程序提供给Windows系统DLL或其它DLL调用的函数,一般用于截获消息、获取系统信息或处理异步事件。应用程序把回调函数的地址指针告诉DLL,而DLL在适当的时候会调用该函数。回调函数必须遵守事先规定好的参数格式和传递方式,否则DLL一调用它就会引起程序或系统的崩溃。通常情况下,回调函数采用标准WindowsAPI的调用方式,即__stdcall,当然,DLL编制者可以自己定义调用方式,但客户程序也必须遵守相同的规定。在__stdcall方式下,函数的参数按从右到左的顺序压入堆栈,除了明确指明是指针或引用外,参数都按值传递,函数返回之前自己负责把参数从堆栈中弹出。
理解回调函数!—— jufengfeng
Function Pointers provide the concept of callback functions.
—— newty.de
*******************************************************************************
看了这么多的资料,我只将每位的定义总结一下就一句话:回调函数就是函数指针的一种用法。
在部分资料上,大量讨论了回调函数怎么被调用,到底被谁调用,还有好多的图形,我认为都没有看到问题的本质。
第二个问题:
*********************************************************************
我实现了一个很简单的回调函数。
#include <stdio.h>
void printWelcome(int len)
{
printf("欢迎欢迎 -- %d/n", len);
}
void printGoodbye(int len)
{
printf("送客送客 -- %d/n", len);
}
void callback(int times, void (* print)(int))
{
int i;
for (i = 0; i < times; ++i)
{
print(i);
}
printf("/n我不知道你是迎客还是送客!/n/n");
}
void main(void)
{
callback(10, printWelcome);
callback(10, printGoodbye);
printWelcome(5);
}
*******************************************************************************
上面的代码没有被任何系统函数调用,说明那些东西只是撒撒土迷迷路人眼而已。还有面相对象编程时,用class给封装起来也是掩人耳目,不要被外表所迷惑。
第三个问题:
*********************************************************************
用过STL的人都知道,在STL中众多算法和程序都用到回调函数,这实现了一种策略。只要任何符合我的标准的函数和计算都可以用我这个公式。你可以实现各种各样的回调函数,只要符合我的格式就能用。
就上面的程序来说,你只要函数格式符合cllback第二个参数的格式不论你给别人做饭、铺床叠被都可以正常工作。这就是回调的作用,把回调实现留给别人。
这是一个用法。
有一位朋友用分层的概念来解释了回调机制:callback函数为B层,main函数和print*函数为A层,A层调用了B层的回调函数callmeback,而B层的回调函数调用了A层的实现函数print*。说白了B层就是一个接口。
这是我的理解。Over!
-
-
js函数参数默认值设置
2018-06-17 12:54:29ES6中给出了函数的默认值设置,下面简单介绍几种设置默认参数的方法一.基本用法function first(x = 1, y = 2) { console.log("x:"+x ,"y:"+ y); } first(); first(100);二.与解构赋值默认值... -
python函数参数的默认参数、元组参数和字典参数例解
2019-01-30 10:54:33python函数除了不带参数,带固定参数之外,还有另外三类函数参数有重要使用价值,是提升python水平需要强化的内容。它们是默认参数、元组参数和字典参数。下面举例子说明。 1.默认参数 即在函数定义时赋值的参数。... -
C语言函数的参数
2019-03-21 23:07:27一、函数的参数可以是变量、变量指针和变量引用: void funcA(int8_t x) { x=x+1; } 代码说明:该函数的参数属于值传递,在调用该函数时,仅仅只是把实参的值拷贝了一份赋值给了形参x,之后的任何操作都不会影响到... -
Python基础(九)——print函数详解,配合参数示例详解
2021-07-11 08:22:132、print()函数 (1)参数1:*objects -- 对象 (2)参数2:sep -- 用来间隔多个对象 (3)参数3:end -- 用来设定以什么结尾。 (4) 参数4:file -- 要写入的文件对象。 (5) 参数5:flush -- 输出是否被... -
php 让函数的参数可有可无(可以不传递参数)
2020-02-26 00:02:58正常情况下,函数一旦声明参数,调用时就必须传入,否则会报错: function demo($e){ return $e; } echo demo(); // Uncaught ArgumentCountError: Too few arguments to function xxxx() 那么如何实现 想传参就... -
js中对函数设置默认参数值
2018-05-14 10:21:02对函数参数设置默认值,本质就是判断是否传入参数或者参数是否为空。 一般而言,最简单的就是下面的方法: function example(name,age){ name=name||'貂蝉'; age=age||21; alert('你好!我是'+name+',今年'... -
c语言中函数参数处理顺序以及默认参数原则
2019-07-04 11:20:59c语言中函数参数处理...下面我们来看2个案例,分析下c语言中函数参数处理顺序。 第一个: #include "stdio.h" void fn(int a,int b,int c) { printf("%d,%d,%d", a, b, c); } void main() { int a = 3; ... -
JavaScript 函数参数——深入理解参数传递、参数默认值、参数的收集与展开
2020-12-02 22:09:00函数允许我们将数据传递进去,通过传递的数据从而影响函数执行结果,使函数更灵活、复用性更强。...创建函数时,function 函数名 后面括号中设定的参数被称为形参;调用函数时,函数名后面括号中传入的参数被称为实参。 -
Python函数总结大全(函数定义,参数种类、返回值等)
2021-05-17 21:14:29关键字参数:**others,便于函数功能的扩展 任意的参数列表 *others 解包参数列表 解包参数列表 函数与函数式编程 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。 函数能提高应用的... -
PyTorch自定义激活函数和为激活函数添加可学习的参数
2019-10-30 10:04:02在深度学习框架PyTorch中已经内置了很多激活函数,如ReLU等,...对于不需要可学习参数的激活函数的实现,比较简单,具体见PyTorch官方教程的一个例子(所用PyTorch版本为1.2): # Inherit from Function class Li... -
Shell脚本函数传递参数
2022-04-14 23:00:42通常,在其他脚本语言中,您可以将参数和参数作为function_name(parameter1, parameter2,…)传递给函数,这在shell脚本函数中不支持。在shell脚本函数中,您可以在函数调用期间直接传递参数,而无需在函数定义中... -
Python函数的参数类型和使用技巧
2021-03-29 13:11:10Python语言支持灵活多样的函数参数,恰当地使用各种形式的参数,会增强代码的复用性和可读性,让代码更加简洁精炼。不过,事物总有其两面性,正因为函数参数的灵活多样,反倒给初学者带了一些困惑。本文从实际需求... -
JavaScript函数参数缺省值
2020-01-29 17:33:40JavaScript函数参数缺省值 本文介绍Es6中如何处理函数的缺省参数。 1. 实参与形参(Argument vs. Parameter) 通常我们不区分实参与形参(Argument vs. Parameter),形参(Parameter)是函数定义时声明的参数,而实参... -
[转载]Python中函数的参数定义和可变参数*args与**args
2020-12-11 06:38:33Python中函数的参数定义和可变参数*...其实只要把函数参数定义搞清楚了,就不难理解了。先说说函数定义,我们都知道,下面的代码定义了一个函数funcAdef funcA():pass显然,函数funcA没有参数(同时啥也不干:D)。下... -
JS处理函数将对象作为参数传递
2018-12-01 15:52:58做项目的时候遇到一个不是很常见的问题,就是js函数传递参数的时候,我们一般是传递一个数字或者是一个字符串,但是当你的需求满足不了的时候,就需要将对象或者数组作为一个参数传递过去,这个时候怎么做呢,今天... -
函数指针作为某个函数的参数及定义函数指针(回调函数)
2017-06-17 22:52:46就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我先给你一个自定义数据类型的例子。 typedef int* PINT; //为int* 类型定义了一个PINT的别名 int main -
C语言 数组做函数参数
2018-04-25 00:20:51看下面代码:int main() { int a[5]={3,6,4,2,5}; char *ptrChar="hello world";//ptrChar是char类型的指针,指向内存空间 int *ptrInt=a;//ptrInt是指向int类型的指针 printf("sizeof(char):%d\... -
以数组作为函数参数的函数调用
2018-11-28 15:04:44调用有参函数时需要提供实参,实参可以是常量变量或者表达式,数组元素就相当于变量,因此数组元素可以用作函数实参,但是不能用作函数形参(因为在函数被调用时临时分配存储单元,不可能为一个数组单独分配存储单元... -
GPU编程自学4 —— CUDA核函数运行参数
2017-08-04 13:20:40中参数的作用是告诉我们该如何启动核函数(比如如何设置线程)。 下面我们先直接介绍参数概念,然后详细说明其意义。 4.1 核函数运行参数 当我们使用 gloabl 声明核函数后 __global__ void kernel... -
matplotlib之pyplot模块plot函数基础一(函数功能、xy参数基本取值,多组数据)
2021-02-09 20:32:05下面通过实例简单演示plot函数的功能。 根据下图可知,plot函数可以绘制带结点标记的线,也可以线和标记点任选其一。 plot函数相当于根据y=f(x)关系,先以x,y为坐标绘制结点,然后用直线连接结点。 import numpy as... -
tensorflow学习之损失函数设置和参数优化
2017-05-30 10:37:32常用损失函数以及参数优化 这次主要介绍常用损失函数以及关于神经网络优化的问题 1.常用损失函数: 神经网络解决的现实问题主要有两大类:分类与回归。分类指的是将未知数据归类到你希望的类别中去,如经典的... -
【Matlab学习笔记】报错——检查对函数‘Link’的调用中是否缺失参数或参数数据类型不正确。
2021-10-02 22:01:43复制的别人的代码(下面的代码),但Matlab总是在报错误——检查对函数‘Link’的调用中是否缺失参数或参数数据类型不正确。 L1 = Link([0 0 0 -pi/2 0],'standard'); L2 = Link([0 0.19 0.650 0 0],'standard'); L3 -
函数之传入参数,传出参数
2016-12-13 23:04:45下面的这个例子用来讲解什么是传出参数,什么是传入参数?通过具体的例子帮助大家理解。#include <stdio.h>int func(int num1, int *num2) { *num2 = 5; return num1 + *num2; }int main() { int num1 = 5; int... -
函数指针和指针函数用法和区别
2018-05-24 08:11:10函数指针和指针函数,在学习 C 语言的时候遇到这两个东西简直头疼,当然还有更头疼的,比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等,描述越长其定义就越复杂,当然理解起来就越难,... -
函数声明带参数与不带参数区别
2015-01-07 14:20:47说说下面两段代码的差异: 代码一 void fun() { printf("hello\n"); } int main() { fun(1,2); return 0; } 代码二 void fun(void) { printf("hello\n"); } int main() { fun(1,2); -
JavaScript 把一个函数作为另一个函数的参数
2018-03-16 13:33:56我们知道JavaScript函数是可以接受参数的例如:var abc="just a test!";function test(temp){ console.log(temp);}test(abc);执行之后输出: just a test! 这里我们把一个变量abc 作为了函数 test() 的...