精华内容
下载资源
问答
  • C++通过匿名对象调用成员函数

    千次阅读 2019-05-15 17:36:29
    C++ 通过匿名对象调用成员函数 刚开始写第一个 leetcode 程序就看到了之前没见到过的东西。首先,框架定义了一个Solution类,我们把方法写在成员函数twoSum(int,int)内,main()函数直接通过构造一个匿名的对象调用...

    C++ 通过匿名对象调用成员函数

    刚开始写第一个 leetcode 程序就看到了之前没见到过的东西。首先,框架定义了一个Solution类,我们把方法写在成员函数twoSum(int,int)内,main()函数直接通过构造一个匿名的对象调用该成员函数。

    vector<int> ret = Solution().twoSum(nums, target);

    进一步总结,如果想要调用成员函数,其实是有三种方法的:

    1、设置成静态成员函数,可以直接通过类名调用 Class::fun();

    2、创建一个对象 object,使用object.fun()方法调用;

    3、创建一个匿名的对象,使用匿名对象调用 Class().fun();

     

    参考:http://www.cnblogs.com/gossiplee/p/4612929.html  《C++临时匿名对象

    #include "iostream"
    using namespace std;
    
    class A
    {
    public:
        A (int _a=0, int _b=0)
        {
            this->a1 = _a;
            this->b1 = _b;
            cout << "construct function called!" << endl;
        }
        A (A &obj)
        {
            cout << "copy_constructor function called!" << endl;
        }
        ~A()
        {
            cout << "objext destory function called!" << endl;
        }
        void printf()
        {
            cout << this->a1 << " " << this->b1 << endl;
    
        }
    protected:
    private:
        int a1;
        int b1;
    };
    
    int main()
    {
        A(10, 10).printf();  //直接通过类名构造一个匿名对象,用后即焚
        cout << "在此处打印之前,匿名对象就已经被析构!" << endl;
        return 0;
    }

    顺便说一下C++ 11中引入的匿名函数

    参考:C++11中的匿名函数(lambda函数,lambda表达式)

      C++11提供了对匿名函数的支持,称为Lambda函数(也叫Lambda表达式). Lambda表达式具体形式如下:

        [capture](parameters)->return-type{body}

      如果没有参数,空的圆括号()可以省略.返回值也可以省略,如果函数体只由一条return语句组成或返回类型为void的话.形如:

         [capture](parameters){body}

      下面举了几个Lambda函数的例子:  

    [](int x, int y) { return x + y; } // 隐式返回类型
    [](int& x) { ++x; }   // 没有return语句 -> lambda 函数的返回类型是'void'
    []() { ++global_x; }  // 没有参数,仅访问某个全局变量
    []{ ++global_x; }     // 与上一个相同,省略了()
    [](int x, int y) -> int { int z = x + y; return z; } //有一个int返回值
    
    
    lambda函数可以引用在它之外声明的变量。这些变量的集合叫做一个闭包,闭包被定义在lambda表达式声明的方括号[]内,这个机制允许这些变量按值或按引用被捕获:
    
    []        //未定义变量.试图在Lambda内使用任何外部变量都是错误的.
    [x, &y]   //x 按值捕获, y 按引用捕获.
    [&]       //用到的任何外部变量都隐式按引用捕获
    [=]       //用到的任何外部变量都隐式按值捕获
    [&, x]    //x显式地按值捕获. 其它变量按引用捕获
    [=, &z]   //z按引用捕获. 其它变量按值捕获
    
    举一个例子
    std::vector<int> some_list;
    int total = 0;
    for (int i=0;i<5;++i) some_list.push_back(i);
    std::for_each(begin(some_list), end(some_list), [&total](int x) 
    {
        total += x;
    });
    
    //此例计算list中所有元素的总和. 变量total被存为lambda函数闭包的一部分. 因为它是栈变量(局部变量)total的引用,所以可以改变它的值

     

    展开全文
  • c++指针对象调用成员函数

    千次阅读 2014-05-24 00:37:02
    c++类的指针对象调用成员函数与一般对象调用成员不同,格式分别是: 普通对象:  objectName.memberfunction(para); 指针对象:  objectName->memberfunction(para) ; or (*objectName).member...

    c++类的指针对象调用成员函数与一般对象调用成员不同,格式分别是:

    普通对象:

           objectName.memberfunction(para);

    指针对象:

          objectName->memberfunction(para) ;   or     (*objectName).memberfunction(para);

    并且c++的成员函数在调用是捆绑了对象,进行了参数传递,所以不需要在调用时显示传递参数。

    /*************************************************************************
    > File Name: t1.cpp
    > Author:
    > Mail: 178*****@qq.com
    > Date: Sat 24 May 2014 12:05:52 AM CST
    ************************************************************************/


    #include<iostream>
    #include<iomanip>
    using namespace std;
    class Date{
    int year,month,date;
    public:
    void set(int x,int y,int z){
    year=x;month=y;date=z;
    }
    bool isLeapyear(){
    if((year%4==0&&year%100!=0)||year%400==0)
    return true;
    else
    return false;
    }
    void print(){
    cout<<setfill('0');
    cout<<setw(4)<<year<<'-'<<setw(2)<<month<<'-'<<setw(2)<<date<<endl;
    }
    };
    int main(){
    Date *p=new Date;//指针对象
    Date *p1=new Date;//指针对象
    (*p).set(2004,10,1);//指针对象调用成员函数
    p1->set(2014,10,1);//指针对象调用成员函数
    if((*p).isLeapyear())
    (*p).print();
    if(p1->isLeapyear())
    p1->print();
    }

    展开全文
  • this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它...

    1.一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数的隐含形参,对各成员的访问均通过this进行。

    this指针的使用:

    一种情况就是,在类的非静态成员函数中返回类对象本身的时候,直接使用 return *this;另外一种情况是当参数与成员变量名相同时使用this指针,如this->n = n (不能写成n = n)。

    为什么要有this,this起到什么作用?话还是要从类和对象说起,定义一个对象,系统要给该对象分配存储空间,如果该类包含了数据成员和成员函数,就要分别给数据和函数的代码分配存储空间。按照正常额思路,如果类定义了2个对象,那么就应该分别给这2个对象的数据和函数分配空间。但事实并非如此,C++的编译系统只用了一段空间来存放在各个共同的函数代码段,在调用各个对象的成员函数时,都与调用这个公共的函数代码。因此,每个对象的存储空间都只是该对象数据成员所占用的存储空间,而不包括成员函数代码所占有的空间,函数代码是存储在对象空间之外的。但是问题就出来了,既然所有对象所调用的成员函数代码只是单独一封,那么成员函数是怎么知道当前调用自己的是哪一个对象呢?

      这时就诞生了this这个自引用的指针。每当创建一个对象时,系统就把this指针初始化为指向该对象,即this指针的值为当前调用成员函数的对象的起始地址。每当调用一个成员函数时,系统就把this指针作为一个隐含的参数传给该函数。不同的对象调用同一个成员函数时,C++编译器将根据成员函数的this指针所指向的对象来确定应该调用哪一个对象的数据成员。通过下面一个简单实例就可说明。

    #include "stdafx.h"
     #include <iostream>
     #include <string>
     
     
     class Num
     {
     private:
     int a;
             std::string objectName;
     public:
             Num(std::string objectName,int a);
     void showNum();
     };
     
     Num::Num(std::string objectName,int a)
     {
     this->objectName=objectName;
     this->a=a;
     }
     
     void Num::showNum()
     {
         std::cout<<this->objectName<<":this="<<this<<" a="<<this->a<<std::endl;
     }
     
     
     int main()
     {
         Num num1("num1",1);
         Num num2("num2",2);
         Num num3("num3",3);
     
         num1.showNum();
         num2.showNum();
         num3.showNum();
     
     return0;
     }

    结果:

    -------------------------------------------------------------------------------------------------

     

    关于this指针的一个经典回答:   

    当你进入一个房子后,你可以看见桌子、椅子、地板等,但是房子你是看不到全貌了。对于一个类的实例来说,你可以看到它的成员函数、成员变量,但是实例本身呢? this是一个指针,它时时刻刻指向你这个实例本身。

    ---------------------------------------------------------------------------------------------

    关于this的若干回答:

    1:this只能在成员函数中使用。全局函数,静态函数都不能使用this。
    2:由此可见,this在成员函数的开始前构造的,在成员的结束后清除。这个生命周期同任一个函数的参数是一样的,没有任何区别。   当调用一个类的成员函数时,编译器将类的指针作为函数的this参数传递进去。
    3:this指针是什么时候创建的?   this在成员函数的开始执行前构造的,在成员的执行结束后清除。   
    4:this指针存放在何处?堆,栈,全局变量,还是其他?   this指针会因编译器不同,而放置的位置不同。可能是栈,也可能是寄存器,甚至全局变量。   
    5:this指针如何传递给类中函数的?绑定?还是在函数参数的首参数就是this指针.那么this指针又是如何找到类实例后函数的?   this是通过函数参数的首参数来传递的。this指针是在调用之前生成的。类实例后的函数,没有这个说法。类在实例化时,只分配类中的变量空间,并没有为函数分配空间。自从类的函数定义完成后,它就在那儿,不会跑的。   
    6:this指针如何访问类中变量的/?   如果不是类,而是结构的话,那么,如何通过结构指针来访问结构中的变量呢?如果你明白这一点的话,那就很好理解这个问题了。   在C++中,类和结构是只有一个区别的:类的成员默认是private,而结构是public。   this是类的指针,如果换成结构,那this就是结构的指针了。   
    7:我们只有获得一个对象后,才能通过对象使用this指针,如果我们知道一个对象this指针的位置可以直接使用吗?   this指针只有在成员函数中才有定义。因此,你获得一个对象后,也不能通过对象使用this指针。所以,我们也无法知道一个对象的this指针的位置(只有在成员函数里才有this指针的位置)。当然,在成员函数里,你是可以知道this指针的位置的(可以&this获得),也可以直接使用的。   
    8:每个类编译后,是否创建一个类中函数表保存函数指针,以便用来调用函数?   普通的类函数(不论是成员函数,还是静态函数),都不会创建一个函数表来保存函数指针的。只有虚函数才会被放到函数表中。   但是,即使是虚函数,如果编译器能明确知道调用的是哪个函数,编译器就不会通过函数表中的指针来间接调用,而是会直接调用该函数

     

     

    展开全文
  • C++成员函数分为静态函数、非静态函数和虚函数三种,在本系列文章中,多处提到static和non-static不影响对象占用的内存,而虚函数需要引入虚指针,所以需要调整对象的内存布局。既然已经解决了数据,函数等在内存...
  • C++成员函数调用

    千次阅读 2019-04-21 22:39:49
    今天看了一篇写得很好的博客:类成员函数调用分析 看完后,有一些小的心得,大概是帮我理了一遍吧。 全局变量和static变量存放在静态存储区。 与静态成员变量和非静态成员变量不同的是:静态成员函数和非静态...

    今天看了一篇写得很好的博客:类成员函数调用分析

    看完后,有一些小的心得,大概是帮我理了一遍吧。

     

                                                                            全局变量和static变量存放在静态存储区。

    与静态成员变量和非静态成员变量不同的是:静态成员函数和非静态成员函数存放在代码区,这两种函数调用时把当前类对象的地址通过隐式传递给函数,非静态成员函数内部有一个this指针,this指针会被调用的类对象地址赋值,因此非静态成员函数能准确得访问类对象的成员变量。而静态成员函数没有this指针,同样可以对函数进行调用,调用方式同全局函数调用,他只能访问静态成员变量(没有this指针嘛)。这里有一个小知识,this指针,是常指针,这就保证了this指针只能改变其指向的对象的内容,并不能改变其指向,达到了访问数据的安全性。由此可见,类的函数参数表隐含有一个this指针,当要调用函数之时,参数表中的局部变量在栈区申请空间,当函数结束时释放。所以,类没有this指针,类的实例(对象)也没有this指针,this指针是函数中的局部变量。

    虚成员函数的调用与上面两种函数不一样,它是在类中存放了一个虚函数指针vptr,vptr存放的是虚函数表vtable的首地址,虚函数表中存放的地址是一个相对地址(这里也不知道对不对,是相对地址吗),真正的地址需要用首地址加上偏移量得到。基类对象内部的虚函数表指针指向基类的虚函数表,派生类对象的虚函数表指针指向派生类的虚函数表。

    sizeof访问的是数据段的内存大小,(这里数据段指的是什么?)

    今天先写到这里,感觉还是有点乱的,应该还有点误区。

    .text(文本段也叫代码段(区)),包含可执行指令、函数代码,用二进制方式存储。对于经常执行的程序,只有一个副本需要存储在内存中,代码段是只读的,以防止程序以外修改指令。

    其他段:1.只读数据段:文字常量、const全局变量 2.符号段。

    .data(初始化的数据段,通常称为数据段(区))包含初始化的全局变量和静态变量

    .bss(未初始化的数据段)包含所有初始化为0和没有显示初始化的全局变量和静态变量

    全局变量和静态变量的存储区域是在一起的,存放在静态存储区,所以静态存储区应该在上面两大数据段区。

    展开全文
  • 1)const对象可以调用非const成员函数吗? 答:不能。const修饰的对象实则修饰的是该对象的this指针,并且const修饰的成员不能进行修改,如果使用const调用非const成员函数,可能会将const对象进行修改。 2)非...
  • 1、在子类内部不能调用父类中私有的成员函数,只能调用受保护和公有的成员函数。 2、在子类外部,子类对象按照继承方式重新给父类成员函数赋予访问权限(上面是 public 继承),此时只有重新赋予的访问权限是 ...
  • C++成员函数指针使用介绍

    万次阅读 多人点赞 2019-09-21 16:07:49
    在之前写过的博客中有介绍过函数指针和指针函数的区别和简单用法(文章在这里),当时的Demo非常简单,都是C语言的写法,但是当在C++中直接像C那样使用类成员函数指针时就会报错:reference to non-static member ...
  • 本文主要介绍C++回调函数中调用类中的非静态成员变量或非静态成员函数 回调函数中调用类中的非静态成员变量或非静态成员函数 【问题】如何在类中封装回调函数? a.回调函数只能是全局的或是静态的。 b.全局函数会...
  • C++中类和对象以及成员函数

    千次阅读 2017-11-17 16:57:23
    一个实体拥有自己的属性和行为,属性是私有的,行为是共有的,在C++中实体对应的就是对象,实体抽象数据类型就是类,属性是成员变量,行为是成员函数。 面向对象思想的三大特征: 封装、继承、多态(静多态,动多态...
  • C++函数调用之静态成员函数

    千次阅读 2014-09-06 11:27:13
    首先,定义如下类A: class A { private: static int val_s; public: static int getVal(){cout ;...我们可以看到,上述类的定义中包含静态成员变量val_s 和静态成员函数getVal() ,对于静态的成员变量,一般
  • 使用空指针调用成员函数会如何? 举个例子:base是基类,里面有两个函数:non-virtual func2 以及 virtual func1; derived是派生类,使用public继承自base,里面有四个函数:virtual func1,non-virtual func3,non...
  • 关于tolua++的资料太少,这个通过实例让你知道如何通过tolua++和C++交互,简单明了。 通过5个文件来演示这个tolua++版 hello world hello.lua ,hello.h ,hello.pkg ,...这个程序实现了脚本调用C++类的成员函数方法
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。 1、 非const成员函数中的隐式参数:classA* this 2、 const成员函数中的隐式参数:const classA* this 根本原因: 1、 const对象的指针为const ...
  • c++调用静态函数的方法

    千次阅读 2020-08-09 13:09:25
    今天在写c++程序时,发新现在的gcc和vc++对于静态函数调用方式有所改变,在旧标准的c++中,调用类的静态方法只能用类名::函数名的方式,在新的标准中,类的对像也可以像调用类的方法一样调用静太函数。示例如下: ...
  • c++对象和常成员函数详解

    千次阅读 2017-07-15 21:52:19
    对象对象是指该对象在其生命周期内,其所有的数据成员的值都不能被改变;定义对象时加上关键字const,该对象就是...1. 常对象只能调用成员函数,不能调用普通成员函数 (除了隐式调用析构函数和构造函数),常成员
  •  C++把类看作类型,把以public方式(严格讲:只有public方式)继承的派生类看做基类的子类型,这样就使得在C++面向对象程序中存在下面的三种多态:  1)对象类型的多态:派生类对象的类型既可以是派生类,也可以是...
  • C++---空指针能调用成员函数吗?

    千次阅读 2019-05-02 12:00:52
    我们知道,一个对象的指针可以调用它的成员函数和虚函数,那么如果一个指向空nullptr的指针,能不能调用它的成员函数和虚函数。 #include<iostream> using namespace std;; class A { public: void func1() ...
  • 对象指针为NULL,为什么还是可以调用成员函数

    千次阅读 多人点赞 2017-03-05 19:53:46
    C++中,空指针是不能够使用的,然而空对象指针有时候却能够调用成员函数。 先来看一下以下程序: #include #include using namespace std; class A { public: static void f1(){ cout; } void f2(){ cout; } void...
  • C++成员函数存储问题点击打开链接 可知C++成员函数不占用对象的存储空间,而是在对象外的空间,而且所有对象共用一段成员... 每个成员函数都有一个特殊的this指针,指向本类的对象,其值为当前被调用成员函数所在...
  • 先写一个日期类,把构造函数,拷贝构造函数,析构函数,赋值运算符的重载都写上,代码如下:class Date{ public: //构造函数 Date() { cout &lt;&lt; "Date()" &lt;&lt; endl; } //...
  • c++类的成员函数调用

    千次阅读 2015-05-28 16:08:15
    我知道C++有一个虚函数列表,对象有指向虚函数列表的指针,对于有虚函数的类对象调用函数时通过虚函数列表里面的指针实现的。。但是对于普通的非虚函数是怎么实现调用的呢、? 是怎么找到非虚函数的入口地址? ...
  • 声明:引用两处博客 http://blog.csdn.net/lg1259156776/ ... ...C调用C++,使用extern “C”则是告诉编译器依照C的方式来编译封装接口,当然接口函数里面的C++语法还是按C++方式编译。 使用extern
  • C++成员函数返回类的对象

    千次阅读 2020-01-14 16:30:59
    //类成员函数返回类的对象 #include<iostream> #include<string> using namespace std; class A { public: A() { x = 50; for(int i=0; i<10; i++) { arr[i]=0; } str1 = "无参...
  • 当使用上述指针或者对象调用成员函数Func()时,会有: obj.Func(); ptr->Func(); 上述调用的背后到底完成了一些什么呢? 假设Func函数的定义如下: Point3d Point3d::Func() const { Float a = getA();
  • c++中类的成员函数调用剖析

    千次阅读 2014-05-08 21:59:06
    此用一个小示例来说明c++成员函数是怎么调用
  • C++利用对象、引用、指针调用函数函数实现原理说明: 每个类的大小比起所有成员数据多4个字节,表明有虚函数的类的大小还要加上一个紧缩的空指针类型的大小。这说明了该在包含虚函数的类中,编译系统自动加入了...
  • 最近代码中看到调用空指针对象成员函数的写法,联想起上次碰到的问题:C++类的成员函数存储方式(是否属于类的对象)两者的本质是一样的,上次只是简单地讨论了下,这次从编译器的角度,来谈一谈这个知识点。...
  • 应用c++11实现c++线程回调函数调用成员函数方法
  • C++调用构造函数的方式

    千次阅读 2019-04-17 10:15:16
    C++中调用构造函数的方式有如下几种: A a = A();//调用默认构造函数 A a = A(xx);//调用带参的构造函数 A a(xx);//调用带参的构造函数的简写形式 A a;//调用默认构造函数的简写形式 class A { public:  A...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 269,883
精华内容 107,953
关键字:

c++对象调用成员函数

c++ 订阅