精华内容
下载资源
问答
  • 普通成员函数当然可以调用常成员函数 class people  { private: char *name; int age; public: people(char *namestr,int i); people( const people& temp); ~people(); char *...
    class A
    {
    public:  void print()const{ cout<<"No const";}
    void test() { print();}
    void test1() const {print();}  
    };
    int main(int argc, char* argv[])

    A a;
    a.print();
    a.test();
    a.test1();


       return 0;

    }


    void test1() const {print();}  常成员函数调用常成员函数,OK!

    如果改成如下:

    class A
    {
    public:  void print(){ cout<<"No const";}
    void test() { print();}
    void test1() const {print();}  
    };
    int main(int argc, char* argv[])

    A a;
    a.print();
    a.test();
    a.test1();


       return 0;
    }

    void test1() const {print();}  常成员函数调用非常成员函数

    则编译器会报错:

    1>e:\poj\poj 1080 human gene function\poj 1080 human gene function\poj 1080 human gene function.cpp(9): error C2662: “A::print”: 不能将“this”指针从“const A”转换为“A &”

    这个问题不是这样考虑的,常成员函数的对象只是只读访问,不允许修改对象的成员变量,所以不能调用非常成员函数,因为,这些成员函数可能修改成员变量。  而普通成员函数当然可以调用常成员函数
    class people 
    {
    private:
    char *name;
    int age;
    public:
    people(char *namestr,int i);
    people( const people& temp);
    ~people();
    char *getname()const;
    int getage()const;
    };
    people::people(char *namestr,int i)
    {   
    int len=strlen(namestr);
    name=new char[len+1];
    strcpy(name,namestr);
        *(name+len)='\0';
    age=i;
    }
    people::people( const people& temp)
    {
    char* tempName=temp.getname();
    int   tempAge=temp.getage();
    int len=strlen(tempName);
    name=new char[len+1];
    strcpy(name,tempName);
        *(name+len)='\0';
    age=tempAge;


    }
    people::~people()
    {
    delete name;
    }
    char *people::getname()const
    {
    return name;
    }
    int people::getage()const
    {
    return age;
    }
    void display(people  x)
    {
    cout<<"people\'s name: "<<x.getname()<<endl;
    cout<<"people\'s age: "<<x.getage()<<endl;
    }


    int main()
    {
    people p("xieyi",30);
    display(p);
    return 0;
    }

    //常对象只能调用常成员函数

    people::people( const people& temp)

    temp是常对象

    temp.getname();

    temp.getage();

    temp调用函数getname(),getage()。

    getname(),getage()必须是常成员函数

    char *getname()const;
    int getage()const;

    如果修改程序为:


    class people 
    {
    private:
    char *name;
    int age;
    public:
    people(char *namestr,int i);
    people( const people& temp);
    ~people();
    char *getname();
    int getage();
    };
    people::people(char *namestr,int i)
    {   
    int len=strlen(namestr);
    name=new char[len+1];
    strcpy(name,namestr);
        *(name+len)='\0';
    age=i;
    }
    people::people( const people& temp)
    {
    char* tempName=temp.getname();
    int   tempAge=temp.getage();
    int len=strlen(tempName);
    name=new char[len+1];
    strcpy(name,tempName);
        *(name+len)='\0';
    age=tempAge;


    }
    people::~people()
    {
    delete name;
    }
    char *people::getname()
    {
    return name;
    }
    int people::getage()
    {
    return age;
    }
    void display(people  x)
    {
    cout<<"people\'s name: "<<x.getname()<<endl;
    cout<<"people\'s age: "<<x.getage()<<endl;
    }


    int main()
    {
    people p("xieyi",30);
    display(p);
    return 0;
    }


    常成员函数意图调用非常成员函数:

    编译会出现如下的错误:

    e:\poj\poj 1080 human gene function\poj 1080 human gene function\poj 1080 human gene function.cpp(27): error C2662: “people::getname”: 不能将“this”指针从“const people”转换为“people &”
    1>          转换丢失限定符
    1>e:\poj\poj 1080 human gene function\poj 1080 human gene function\poj 1080 human gene function.cpp(28): error C2662: “people::getage”: 不能将“this”指针从“const people”转换为“people &”
    1>          转换丢失限定符


    展开全文
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。 1、 非const成员函数中的隐式参数:classA* this 2、 const成员函数中的隐式参数:const classA* this 根本原因: 1、 const对象的指针为const ...

    引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。
    1、 非const成员函数中的隐式参数:classA* this
    2、 const成员函数中的隐式参数:const classA* this

    根本原因:
    1、 const对象的指针为const classA* this,因此传入非const成员函数时编译器报错(类型不匹配,无法从const 指针转换为非const指针);但传入const成员函数则类型匹配。

    2、非const对象的指针为classA* this,可以调用const成员函数,因为const修饰符保证了不会修改该对象。

    详细代码案例解释见:为什么const对象只能调用const成员函数,而不能调用非const成员函数?

    总结:

    1、const对象只能调用const成员函数、不能调用非const成员函数;
    2、非const对象可以调用const成员函数。

    展开全文
  • 在c++中,我们可以用const来定义一个const对象,const对象是不可以调用类中的非const成员函数,这是为什么呢?下面是我总结的一些原理。 假设有一个类,名字为test代码如下:   1 class test{ 2 int i; 3 pub

    参考:http://www.cnblogs.com/cplinux/articles/5553716.html

    http://blog.csdn.net/lanxuezaipiao/article/details/41647333#comments

    在c++中,我们可以用const来定义一个const对象,const对象是不可以调用类中的非const成员函数,这是为什么呢?下面是总结的一些原理。

    假设有一个类,名字为test代码如下:

     

    复制代码
    1 class test{
    2   int i;
    3 public:
    4   void print();
    5   test(int i);
    6 };
    复制代码

     

     

    我们知道c++在类的成员函数中还会隐式传入一个指向当前对象的this指针,所以在test类中,实际的print函数应该是这样的void print(test * this);,这代表一个指向test对象的指针this被传入到了print函数中

    假如现在我们用test类创建一个对象,

    1 test obj1(12);
    2 obj1.print();

    第二句,obj1.print();其实相当于print(&obj1);,即把当前的对象obj1的指针传递到print()函数,这是没问题的

    如果用test类创建一个const对象,然后去调用print()函数呢?这就会出现问题

    const test obj2(122);
    obj2.print();

    这时obj2对象的指针就会传递给test *this 指针,而obj2的地址翻译成指针类型应该是这样的,const test* this,即这时会出现类型不匹配的错误,在visual studio 中会出现类似于下面的错误:

    4

    所以通过上面的说明,我们知道了为什么const 对象不能调用非const成员函数。

     

    下面解释为什么const 对象可以调用const成员函数,

    1 class test{
    2 public:
    3      void print()const;
    4 };

    前面我们把非const成员函数print(),翻译了一下,同样const成员函数也要翻译,void print()const; 可以翻译成 void print(const test* this);,那么常量对象的地址翻译是const test* this; 是和void print() const;中this指针的类型是一样的,所以常量对象可以调用const成员函数。

     

    有一个点要注意,在c++中其实是有最小权限原则的,非const对象是可以调用const成员函数的。

    任何不修改成员数据的函数应该声明为const函数,这样它可以由const对象使用。 
    注意:构造函数和析构函数都不是const成员函数,因为它们在初始化和清理时,总是对对象作些修改。

    引申:如何在const成员函数里修改成员 —— 按位和与按成员const

    如果我们想要建立一个const成员函数,但仍然想在对象里改变某些数据,这时该怎么办呢?这关系到按位const和按成员const的区别。按位const意思是对象中的每个位是固定的,所以对象的每个位映像从不改变。按成员const意思是,虽然整个对象从概念上讲是不变的,但是某个成员可能有变化。当编译器被告知一个对象是const对象时,它将保护这个对象。

    这里我们要介绍在const成员函数里改变数据成员的两种方法。

    • 第一种方法已成为过去,称为“强制转换const”。它以相当奇怪的方式执行。取this(这个关键字产生当前对象的地址)并把它强制转换成指向当前类型对象的指针。看来this已经是我们所需的指针,但它是一个const指针,所以,还应把它强制转换成一个普通指针,这样就可以在运算中去掉常量性。下面是一个例子:

      这种方法可行,在过去的程序代码里可以看到这种用法,但这不是首选的技术。问题是:this没有用const修饰,这在一个对象的成员函数里被隐藏,这样,如果用户不能见到源代码(并找到用这种方法的地方),就不知道发生了什么

    class Y {
    int i, j;
    public:
    Y() { i = j = 0; }
    void f() const;
    };
    void Y::f() const {
    //! i++; // error
    ((Y*)this)->j++; // ok , cast away const feature.
    }
    • 第二种方法也是推荐的方法,就是在类声明里使用关键字mutable,以指定一个特定的数据成员可以在一个const对象里被改变。 
    class Y {
    int i;
    mutable int j;
    public:
    Y() { i = j = 0; }
    void f() const;
    };
    void Y::f() const {
    //! i++; // error
    ((Y*)this)->j++; // ok , mutable.
    }
    展开全文
  • 常对象只能调用常函数成员 c++

    千次阅读 2015-08-18 21:06:35
    关于 常对象只能调用常函数成员,不能调用非const 函数成员问题,我有点想法 就是我想到的一个角度来解释为什么。 你看,常函数成员的特性就是要在函数后面加一个const 修饰关键字 以 int getX() const;为例,,...


    关于 常对象只能调用常函数成员,不能调用非const 函数成员问题,我有点想法


    就是我想到的一个角度来解释为什么。

    你看,常函数成员的特性就是要在函数后面加一个const 修饰关键字

    以  int getX() const;为例,,将之作解析, 即, int getX(const Coordinate * this);
    这次我们重点看的不是 const 修饰谁的问题, 而是 this 的类型问题

    显然,这里的 this 的类型是 const Coordinate * 类型


    也就是说, 这个函数所需要接受的形参类型是 const Coordinate * 类型
    问题来了  const Coordinate * 类型 和 Coordinate * 类型,到底是什么关系,还是没有关系的两种类型???

    我想说的就是, 假定 const Coordinate * 和 Coordinate * 是两种类型
    因为 常对象的地址是const Coordinate * 类型,而成员函数调用的时候必须接收所在对象的指针
    也就是说,常对象中的成员函数必须接收常对象的地址,也就是 const Coordinate * 类型地址
    为此要符合类型的匹配,成员函数必须要用 const Coordinate * 类型的形参来接收,

    所以必须将成员函数修饰为 const ,即常对象函数 

    只有这样才能满足类型的匹配!!!


    void test()const 
    {
    cout << "jack is a good boy!!!" << endl;
    }


    void test ()
    {
    cout << "via via via " << endl;
    }


    /*这两个函数互为重载,可见  const Coordinate * 和 Coordinate *  确实不一样!!!*/ 

    Jack_Lu

    展开全文
  • 一、const1、常对象只能调用常成员函数2、普通对象可以调用全部的成员函数包括常成员函数3、方法不能调用普通方法 可以调用方法、静态成员方法4、普通方法可以调用方法解释:当一个成员函数被调用时,自动向它...
  • c++常对象常成员函数详解

    千次阅读 2017-07-15 21:52:19
    常对象常对象是指该对象在其生命周期内,其所有的数据成员的值都不被改变;定义对象时加上关键字const,该对象就是...1. 常对象只能调用成员函数,不能调用普通成员函数 (除了隐式调用析构函数和构造函数),成员
  • 【C++】 常对象数据成员、常成员函数总结

    千次阅读 多人点赞 2019-03-24 15:07:25
     ◆ 数据成员在声明时赋初始值(普通数据成员也是),数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始化均可。  ◆ PS:类的成员对象若要传入参数初始化,则必须在...
  • 文章目录1、简单函数形式1.1 普通函数1.2 类成员函数1.3 仿函数1.4 函数指针1.5 成员函数指针 一组执行任务的语句都可以视为一个函数,一个可调用对象。在程序设计的过程中,我们习惯于把那些具有复用性的一组语句...
  • 通过常对象调用普通成员函数,但是可以通过普通对象调用成员函数。对象只能调用成员函数。对象的声明如下: const   const  两种声明完全一样没有任何区别。 1、通过下面例子来理解对象: A、请...
  • 数据成员: const 类型说明符 数据成员 如:const int year 成员函数:类型说明符 函数名(参数表) const ...2.数据成员可以被成员函数访问,也可被普通成员函数访问。 3.如果将一个对象说明为一个常对象,...
  • C++---空指针能调用成员函数吗?

    千次阅读 2019-05-02 12:00:52
    我们知道,一个对象的指针可以调用它的成员函数和虚函数,那么如果一个指向空nullptr的指针,能调用它的成员函数和虚函数。 #include<iostream> using namespace std;; class A { public: void func1() ...
  • 通过该对象只能调用它的成员函数,而不能调用它的普通成员函数。以防普通成员函数会修改数据成员的值。但如果一定要修改常对象数据成员的值,可以将该数据成员声明为mutable,如: mutable int count;//把count...
  • 2.常对象不能够调用普通成员函数——因为普通成员函数可能会修改对象的数据类型,这是不安全的。 3.常对象可以调用静态成员函数,成员函数,其实也可以调友元函数 (但是这里不对每一个具体展开了,就只是为了...
  • 静态成员函数是类共享的函数,而普通成员变量则是类所独有的,所以在静态成员函数调用普通成员变量,最起码直接调用是不可以的。 这是一个小问题,但遇事要慢慢来,不要急。写这篇Blog最主要要提醒自己,凡事必有...
  • c++ 常成员函数常对象

    千次阅读 多人点赞 2014-06-17 13:30:17
    先明确几个概念: 1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数
  • 非const对象也可以调用const成员函数

    千次阅读 2014-12-31 16:10:40
    当一个类只有const成员函数的时候,非const对象也可以调用const成员函数: // ConstTest.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; class A { ...
  • c++指针对象调用成员函数

    千次阅读 2014-05-24 00:37:02
    c++类的指针对象调用成员函数与一般对象调用成员不同,格式分别是: 普通对象:  objectName.memberfunction(para); 指针对象:  objectName->memberfunction(para) ; or (*objectName).member...
  • delete是C++中的一个运算符,它是和new配合起来使用。我们知道new的实际操作是先分配一块内存,再调用对象的构造函数。...这里类的成员函数,大致分成类的普通成员函数和析构函数中对delete的调用。 实践是最好的...
  • this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它...
  • //外部普通函数获取内部类对象指针,这种方法不行,可以通过this全局变量来达到这个目的 //CActiveXVidyoCtrl *pDlg123 = (CActiveXVidyoCtrl*)(AfxGetApp()->GetMainWnd()); XXDlg *g_pDlg = NULL;//全局变量 xxx:...
  • C++普通函数,普通成员函数、静态成员函数的区别

    千次阅读 多人点赞 2017-05-13 22:24:53
    1普通函数:属于全局函数,不受具体类...普通成员函数本质上是一个包含指向具体对象this指针的普通函数,即c++类的普通成员函数都隐式包含一个指向当前对象的this指针。 例如:定义一个类: class myClass { publi
  • 常成员函数能调用非常成员函数:比如:#include&lt;iostream&gt; using namespace std; class A { const void print(){cout&lt;&lt;fun();} }; int fun() { return 2; } int main() { A.a; a....
  • C++中使用空对象指针调用成员函数

    千次阅读 2016-02-23 23:36:03
    C++中,空指针是不能够使用的,然后空对象指针有时候却能够调用成员函数。  下面定义一个简单的类: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ...
  • 普通成员函数需要实例化才能调用,对于每一个实例来说,普通成员函数是自己独有的。 #include<iostream> class Person { public: void ordinaryfunc();//声明一个普通成员函数 vo...
  • 当使用上述指针或者对象调用成员函数Func()时,会有: obj.Func(); ptr->Func(); 上述调用的背后到底完成了一些什么呢? 假设Func函数的定义如下: Point3d Point3d::Func() const { Float a = getA();
  • 1.成员变量:成员变量是用关键字const来声明的变量,const位于变量前或者类型前都一样,用const修饰的变量只能...注明:常成员函数只能通过构造函数的初始化表对其进行初始化,成员变量所在类中所有的构造函数...
  • C++: 外部函数调用成员函数的方式

    千次阅读 2019-02-26 10:11:23
    普通函数(入参一定)调用成员函数 pthread_create的钩子函数,void ()(void * data)-&gt; void 可传入this指针 ,进而调用成员函数 signal的钩子函数,void (*)(int signal)-&gt; 通过参数...
  • 在基本数据类型中有常量,类比到类类型中就是常对象,其实常量也是常对象常对象的声明方式:const类名 对象名;。常对象的数据成员不被改变,...但是普通对象也可以访问常成员函数,在访问过程中,普通对象会被视
  • C++ - 对象模型之 成员函数调用

    千次阅读 2013-02-23 14:42:00
    C++对象模型目录 C++ - 对象模型之 编译器何时才会自行添加构造函数 C++ - 对象模型之 内存布局 ... - 对象模型之 成员函数调用 ... - 对象模型之 构造和析构函数都干了什么 ...C++ - 对象模型之 成员函数调用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 179,812
精华内容 71,924
关键字:

常对象能调用普通成员函数