精华内容
下载资源
问答
  • 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定义函数时的参数&amp&semi;调用函数时的传参

    一.定义函数: 1.位置参数:直接定义参数 2.默认参数(或者关键字参数):参数名 = "默认值" 3.位置参数必须在默认参数之前 二.调用函数: 1.按位置传,直接写参数的值 2 ...

    python定义函数时的默认返回值

    python定义函数时,一般都会有指定返回值,如果没有显式指定返回值,那么python就会默认返回值为None, 即隐式返回语句: return None 执行如下代码 def now(): prin ...

    python中函数的默认参数陷阱问题

    其实也不能说是陷阱,只是一个不容易注意到的地方,尤其是有其他java/c++类编程语言经验的人员,这里涉及到python的一个特点,所以笔者说是陷阱只是一个噱头而已. def test(item, b ...

    python定义函数时,形参前加&ast;和&ast;&ast;的意义

    转发: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&plus;&plus;虚函数使用默认参数的注意事项

    本文为大便一箩筐的原创内容,转载请注明出处,谢谢:http://www.cnblogs.com/dbylk/ 备忘一个关于虚函数的小知识点 使用多态调用一个类型中定义的虚函数时,编译器会根据指针的当前 ...

    C&plus;&plus;中函数的默认参数

    使用方法: (1)在函数声明或定义时,直接对参数赋值,该参数就是默认参数. (2)在函数调用时,省略部分或全部参数,这时就会使用默认参数进行代替. 注意事项: (1)一般在声明函数是设置默认参数. 如 ...

    随机推荐

    重写AgileEAS&period;NET SOA 中间件平台账号密码的加密算法

    一.平台简介 AgileEAS.NET SOA 中间件平台是一款基于基于敏捷并行开发思想和Microsoft .Net构件(组件)开发技术而构建的一个快速开发应用平台.用于帮助中小型软件企业建立一条适 ...

    用Access作为后台数据库支撑。

    /// /// 读取Excel文档 /// /// 文件名称&l ...

    使用C&num; WinForm制作 员工打卡项目 -- S2 2&period;3

    新建一个员工类,存储员工的信息 新建一个List<>集合,并在load事件中实例化三个员工对象 DataGridView绑定数据源,可以显示出数据 点击查询按钮,查询工号等同于输入的数的员 ...

    &lbrack;Unity3D&rsqb;开发视图中的标记 - Gizmos

    这个类用来做自己的组件很不错,比如下面这个图的路径点,他其实是个Empty Object,可以自己加脚本让他带上标记.官方解释还可以用来做帮助提示的-.- 大游戏场景的制作时候,你可以用这个在地图上写 ...

    c&num;&plus;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 之前,不能直接为函数的参数指定默认值,只能采用变通的方法。

     
    1. function log(x, y) {
    2. y = y || 'World';
    3. console.log(x, y);
    4. }
    5. log('Hello') // Hello World
    6. log('Hello', 'China') // Hello China
    7. log('Hello', '') // Hello World

    上面代码检查函数log的参数y有没有赋值,如果没有,则指定默认值为World。这种写法的缺点在于,如果参数y赋值了,但是对应的布尔值为false,则该赋值不起作用。就像上面代码的最后一行,参数y等于空字符,结果被改为默认值。

    为了避免这个问题,通常需要先判断一下参数y是否被赋值,如果没有,再等于默认值。

     
    1. if (typeof y === 'undefined') {
    2. y = 'World';
    3. }

    ES6 允许为函数的参数设置默认值,即直接写在参数定义的后面。

     
    1. function log(x, y = 'World') {
    2. console.log(x, y);
    3. }
    4. log('Hello') // Hello World
    5. log('Hello', 'China') // Hello China
    6. log('Hello', '') // Hello

    可以看到,ES6 的写法比 ES5 简洁许多,而且非常自然。下面是另一个例子。

     
    1. function Point(x = 0, y = 0) {
    2. this.x = x;
    3. this.y = y;
    4. }
    5. const p = new Point();
    6. p // { x: 0, y: 0 }

    除了简洁,ES6 的写法还有两个好处:首先,阅读代码的人,可以立刻意识到哪些参数是可以省略的,不用查看函数体或文档;其次,有利于将来的代码优化,即使未来的版本在对外接口中,彻底拿掉这个参数,也不会导致以前的代码无法运行。

    参数变量是默认声明的,所以不能用letconst再次声明。

     
    1. function foo(x = 5) {
    2. let x = 1; // error
    3. const x = 2; // error
    4. }

    上面代码中,参数变量x是默认声明的,在函数体中,不能用letconst再次声明,否则会报错。

    使用参数默认值时,函数不能有同名参数。

     
    1. // 不报错
    2. function foo(x, x, y) {
    3. // ...
    4. }
    5. // 报错
    6. function foo(x, x, y = 1) {
    7. // ...
    8. }
    9. // SyntaxError: Duplicate parameter name not allowed in this context

    另外,一个容易忽略的地方是,参数默认值不是传值的,而是每次都重新计算默认值表达式的值。也就是说,参数默认值是惰性求值的。

     
    1. let x = 99;
    2. function foo(p = x + 1) {
    3. console.log(p);
    4. }
    5. foo() // 100
    6. x = 100;
    7. foo() // 101

    上面代码中,参数p的默认值是x + 1。这时,每次调用函数foo,都会重新计算x + 1,而不是默认p等于 100。

    与解构赋值默认值结合使用

    参数默认值可以与解构赋值的默认值,结合起来使用。

     
    1. function foo({x, y = 5}) {
    2. console.log(x, y);
    3. }
    4. foo({}) // undefined 5
    5. foo({x: 1}) // 1 5
    6. foo({x: 1, y: 2}) // 1 2
    7. foo() // TypeError: Cannot read property 'x' of undefined

    上面代码只使用了对象的解构赋值默认值,没有使用函数参数的默认值。只有当函数foo的参数是一个对象时,变量xy才会通过解构赋值生成。如果函数foo调用时没提供参数,变量xy就不会生成,从而报错。通过提供函数参数的默认值,就可以避免这种情况。

     
    1. function foo({x, y = 5} = {}) {
    2. console.log(x, y);
    3. }
    4. foo() // undefined 5

    上面代码指定,如果没有提供参数,函数foo的参数默认为一个空对象。

    下面是另一个解构赋值默认值的例子。

     
    1. function fetch(url, { body = '', method = 'GET', headers = {} }) {
    2. console.log(method);
    3. }
    4. fetch('http://example.com', {})
    5. // "GET"
    6. fetch('http://example.com')
    7. // 报错

    上面代码中,如果函数fetch的第二个参数是一个对象,就可以为它的三个属性设置默认值。这种写法不能省略第二个参数,如果结合函数参数的默认值,就可以省略第二个参数。这时,就出现了双重默认值。

     
    1. function fetch(url, { body = '', method = 'GET', headers = {} } = {}) {
    2. console.log(method);
    3. }
    4. fetch('http://example.com')
    5. // "GET"

    上面代码中,函数fetch没有第二个参数时,函数参数的默认值就会生效,然后才是解构赋值的默认值生效,变量method才会取到默认值GET

    作为练习,请问下面两种写法有什么差别?

     
    1. // 写法一
    2. function m1({x = 0, y = 0} = {}) {
    3. return [x, y];
    4. }
    5. // 写法二
    6. function m2({x, y} = { x: 0, y: 0 }) {
    7. return [x, y];
    8. }

    上面两种写法都对函数的参数设定了默认值,区别是写法一函数参数的默认值是空对象,但是设置了对象解构赋值的默认值;写法二函数参数的默认值是一个有具体属性的对象,但是没有设置对象解构赋值的默认值。

     
    1. // 函数没有参数的情况
    2. m1() // [0, 0]
    3. m2() // [0, 0]
    4. // x 和 y 都有值的情况
    5. m1({x: 3, y: 8}) // [3, 8]
    6. m2({x: 3, y: 8}) // [3, 8]
    7. // x 有值,y 无值的情况
    8. m1({x: 3}) // [3, 0]
    9. m2({x: 3}) // [3, undefined]
    10. // x 和 y 都无值的情况
    11. m1({}) // [0, 0];
    12. m2({}) // [undefined, undefined]
    13. m1({z: 3}) // [0, 0]
    14. m2({z: 3}) // [undefined, undefined]

    参数默认值的位置

    通常情况下,定义了默认值的参数,应该是函数的尾参数。因为这样比较容易看出来,到底省略了哪些参数。如果非尾部的参数设置默认值,实际上这个参数是没法省略的。

     
    1. // 例一
    2. function f(x = 1, y) {
    3. return [x, y];
    4. }
    5. f() // [1, undefined]
    6. f(2) // [2, undefined])
    7. f(, 1) // 报错
    8. f(undefined, 1) // [1, 1]
    9. // 例二
    10. function f(x, y = 5, z) {
    11. return [x, y, z];
    12. }
    13. f() // [undefined, 5, undefined]
    14. f(1) // [1, 5, undefined]
    15. f(1, ,2) // 报错
    16. f(1, undefined, 2) // [1, 5, 2]

    上面代码中,有默认值的参数都不是尾参数。这时,无法只省略该参数,而不省略它后面的参数,除非显式输入undefined

    如果传入undefined,将触发该参数等于默认值,null则没有这个效果。

     
    1. function foo(x = 5, y = 6) {
    2. console.log(x, y);
    3. }
    4. foo(undefined, null)
    5. // 5 null

    上面代码中,x参数对应undefined,结果触发了默认值,y参数等于null,就没有触发默认值。

    函数的 length 属性

    指定了默认值以后,函数的length属性,将返回没有指定默认值的参数个数。也就是说,指定了默认值后,length属性将失真。

     
    1. (function (a) {}).length // 1
    2. (function (a = 5) {}).length // 0
    3. (function (a, b, c = 5) {}).length // 2

    上面代码中,length属性的返回值,等于函数的参数个数减去指定了默认值的参数个数。比如,上面最后一个函数,定义了 3 个参数,其中有一个参数c指定了默认值,因此length属性等于3减去1,最后得到2

    这是因为length属性的含义是,该函数预期传入的参数个数。某个参数指定默认值以后,预期传入的参数个数就不包括这个参数了。同理,后文的 rest 参数也不会计入length属性。

     
    1. (function(...args) {}).length // 0

    如果设置了默认值的参数不是尾参数,那么length属性也不再计入后面的参数了。

     
    1. (function (a = 0, b, c) {}).length // 0
    2. (function (a, b = 1, c) {}).length // 1

    作用域

    一旦设置了参数的默认值,函数进行声明初始化时,参数会形成一个单独的作用域(context)。等到初始化结束,这个作用域就会消失。这种语法行为,在不设置参数默认值时,是不会出现的。

     
    1. var x = 1;
    2. function f(x, y = x) {
    3. console.log(y);
    4. }
    5. f(2) // 2

    上面代码中,参数y的默认值等于变量x。调用函数f时,参数形成一个单独的作用域。在这个作用域里面,默认值变量x指向第一个参数x,而不是全局变量x,所以输出是2

    再看下面的例子。

     
    1. let x = 1;
    2. function f(y = x) {
    3. let x = 2;
    4. console.log(y);
    5. }
    6. f() // 1

    上面代码中,函数f调用时,参数y = x形成一个单独的作用域。这个作用域里面,变量x本身没有定义,所以指向外层的全局变量x。函数调用时,函数体内部的局部变量x影响不到默认值变量x

    如果此时,全局变量x不存在,就会报错。

     
    1. function f(y = x) {
    2. let x = 2;
    3. console.log(y);
    4. }
    5. f() // ReferenceError: x is not defined

    下面这样写,也会报错。

     
    1. var x = 1;
    2. function foo(x = x) {
    3. // ...
    4. }
    5. foo() // ReferenceError: x is not defined

    上面代码中,参数x = x形成一个单独作用域。实际执行的是let x = x,由于暂时性死区的原因,这行代码会报错”x 未定义“。

    如果参数的默认值是一个函数,该函数的作用域也遵守这个规则。请看下面的例子。

     
    1. let foo = 'outer';
    2. function bar(func = () => foo) {
    3. let foo = 'inner';
    4. console.log(func());
    5. }
    6. bar(); // outer

    上面代码中,函数bar的参数func的默认值是一个匿名函数,返回值为变量foo。函数参数形成的单独作用域里面,并没有定义变量foo,所以foo指向外层的全局变量foo,因此输出outer

    如果写成下面这样,就会报错。

     
    1. function bar(func = () => foo) {
    2. let foo = 'inner';
    3. console.log(func());
    4. }
    5. bar() // ReferenceError: foo is not defined

    上面代码中,匿名函数里面的foo指向函数外层,但是函数外层并没有声明变量foo,所以就报错了。

    下面是一个更复杂的例子。

     
    1. var x = 1;
    2. function foo(x, y = function() { x = 2; }) {
    3. var x = 3;
    4. y();
    5. console.log(x);
    6. }
    7. foo() // 3
    8. x // 1

    上面代码中,函数foo的参数形成一个单独作用域。这个作用域里面,首先声明了变量x,然后声明了变量yy的默认值是一个匿名函数。这个匿名函数内部的变量x,指向同一个作用域的第一个参数x。函数foo内部又声明了一个内部变量x,该变量与第一个参数x由于不是同一个作用域,所以不是同一个变量,因此执行y后,内部变量x和外部全局变量x的值都没变。

    如果将var x = 3var去除,函数foo的内部变量x就指向第一个参数x,与匿名函数内部的x是一致的,所以最后输出的就是2,而外层的全局变量x依然不受影响。

     
    1. var x = 1;
    2. function foo(x, y = function() { x = 2; }) {
    3. x = 3;
    4. y();
    5. console.log(x);
    6. }
    7. foo() // 2
    8. x // 1

    应用

    利用参数默认值,可以指定某一个参数不得省略,如果省略就抛出一个错误。

     
    1. function throwIfMissing() {
    2. throw new Error('Missing parameter');
    3. }
    4. function foo(mustBeProvided = throwIfMissing()) {
    5. return mustBeProvided;
    6. }
    7. foo()
    8. // Error: Missing parameter

    上面代码的foo函数,如果调用的时候没有参数,就会调用默认值throwIfMissing函数,从而抛出一个错误。

    从上面代码还可以看到,参数mustBeProvided的默认值等于throwIfMissing函数的运行结果(注意函数名throwIfMissing之后有一对圆括号),这表明参数的默认值不是在定义时执行,而是在运行时执行。如果参数已经赋值,默认值中的函数就不会运行。

    另外,可以将参数默认值设为undefined,表明这个参数是可以省略的。

     
    1. function foo(optional = undefined) { ··· }
    展开全文
  • 但是我知道你要用哪个函数来处理这个命令, 我也知道你的主模块是什么.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);
    }
    输出结果:略
     

     

     

    1. 函数指针是指向函数的指针变量。c在编译时,每一个函数都有一个入口地址,该入口地址就是函数指针指向的地址处。有了指向函数的指针变量后。可以通过该指针变量调用函数,函数指针有两个用途:调用函数、做函数的参数:

      1. 调用函数,如下所示:

     

    输出结果如下:

    由以上可以说明成功调用。

     

       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:29
    ES6中给出了函数的默认值设置下面简单介绍几种设置默认参数的方法一.基本用法function first(x = 1, y = 2) {  console.log("x:"+x ,"y:"+ y); } first(); first(100);二.与解构赋值默认值...
  • python函数除了带参数,带固定参数之外,还有另外三类函数参数有重要使用价值,是提升python水平需要强化的内容。它们是默认参数、元组参数和字典参数。下面举例子说明。 1.默认参数 即在函数定义时赋值的参数。...
  • C语言函数参数

    千次阅读 多人点赞 2019-03-21 23:07:27
    一、函数参数可以是变量、变量指针和变量引用: void funcA(int8_t x) { x=x+1; } 代码说明:该函数参数属于值传递,在调用该函数时,仅仅只是把实参的值拷贝了一份赋值给了形参x,之后的任何操作都不会影响到...
  • 2、print()函数 (1)参数1:*objects -- 对象 (2)参数2:sep -- 用来间隔多个对象 (3)参数3:end -- 用来设定以什么结尾。 (4) 参数4:file -- 要写入的文件对象。 (5) 参数5:flush -- 输出是否被...
  • 正常情况下,函数一旦声明参数,调用时就必须传入,否则会报错: 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:59
    c语言中函数参数处理...下面我们来看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; ...
  • 函数允许我们将数据传递进去,通过传递的数据从而影响函数执行结果,使函数更灵活、复用性更强。...创建函数时,function 函数名 后面括号中设定的参数被称为形参;调用函数时,函数名后面括号中传入的参数被称为实参。
  • 关键字参数:**others,便于函数功能的扩展 任意的参数列表 *others 解包参数列表 解包参数列表 函数函数式编程 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。 函数能提高应用的...
  • 在深度学习框架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:10
    Python语言支持灵活多样的函数参数,恰当地使用各种形式的参数,会增强代码的复用性和可读性,让代码更加简洁精炼。不过,事物总有其两面性,正因为函数参数的灵活多样,反倒给初学者带了一些困惑。本文从实际需求...
  • JavaScript函数参数缺省值

    千次阅读 2020-01-29 17:33:40
    JavaScript函数参数缺省值 本文介绍Es6中如何处理函数的缺省参数。 1. 实参与形参(Argument vs. Parameter) 通常我们区分实参与形参(Argument vs. Parameter),形参(Parameter)是函数定义时声明的参数,而实参...
  • Python中函数的参数定义和可变参数*...其实只要把函数参数定义搞清楚了,就难理解了。先说说函数定义,我们都知道,下面的代码定义了一个函数funcAdef funcA():pass显然,函数funcA没有参数(同时啥也干:D)。下...
  • JS处理函数将对象作为参数传递

    千次阅读 2018-12-01 15:52:58
    做项目的时候遇到一个不是很常见的问题,就是js函数传递参数的时候,我们一般是传递一个数字或者是一个字符串,但是当你的需求满足了的时候,就需要将对象或者数组作为一个参数传递过去,这个时候怎么做呢,今天...
  • 就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我先给你一个自定义数据类型的例子。 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
    调用有参函数需要提供实参,实参可以是常量变量或者表达式,数组元素就相当于变量,因此数组元素可以用作函数实参,但是能用作函数形参(因为在函数被调用时临时分配存储单元,可能为一个数组单独分配存储单元...
  • 参数的作用是告诉我们该如何启动核函数(比如如何设置线程)。 下面我们先直接介绍参数概念,然后详细说明其意义。 4.1 核函数运行参数 当我们使用 gloabl 声明核函数后 __global__ void kernel...
  • 下面通过实例简单演示plot函数的功能。 根据下图可知,plot函数可以绘制带结点标记的线,也可以线和标记点任选其一。 plot函数相当于根据y=f(x)关系,先以x,y为坐标绘制结点,然后用直线连接结点。 import numpy as...
  • 常用损失函数以及参数优化   这次主要介绍常用损失函数以及关于神经网络优化的问题   1.常用损失函数: 神经网络解决的现实问题主要有两大类:分类与回归。分类指的是将未知数据归类到你希望的类别中去,如经典的...
  • 复制的别人的代码(下面的代码),但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函数是可以接受参数的例如:var abc="just a test!";function test(temp){ console.log(temp);}test(abc);执行之后输出: just a test! 这里我们把一个变量abc 作为了函数 test() 的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,008,478
精华内容 803,391
关键字:

下面哪个函数不需要设置参数