精华内容
下载资源
问答
  • 引发原因: 由调用成员函数时隐式传入的当前对象的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成员函数。

    展开全文
  • 常成员函数对象只是只读访问,不允许修改对象的成员变量,所以不能调用非常成员函数,因为,这些成员函数可能修改成员变量。 而普通成员函数当然可以调用常成员函数 class people  { private: 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>          转换丢失限定符


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

    在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成员函数

    千次阅读 2019-07-13 22:38:52
    常量成员函数 (const member ...const对象是不可以调用类中的const成员函数。原因之后解释。 假设现在有如下代码: class test{  int i; public:  void print();  test(int i); }; test obj1(12); obj1.p...
    • 常量成员函数 (const member function), 可读取类中的数据成员,但不能修改。利用这个特性来对成员函数加以修饰。
    • const对象是不可以调用类中的非const成员函数。原因之后解释。

    假设现在有如下代码:

    class test{
      int i;
    public:
      void print();
      test(int i);
    };
    
    test obj1(12);
    obj1.print();
    

    默认this指针

    对象调用成员函数时,在形参列表的最前面加一个形参this,但这是隐式的。this指针是默认指向调用函数的当前对象的,所以,很自然,this是一个常量指针test * const,因为不可以修改this指针代表的地址。

    但当成员函数的参数列表(即小括号)后加了const关键字(void print() const;),此成员函数为常量成员函数,此时它的隐式this形参为const test * const,即不可以通过this指针来改变指向对象的值。这就是“常量成员函数可读取类中的数据成员,但不能修改”的原因。

    和Python有点像,在定义类的函数时,每个函数的参数列表的第一个参数必须为self,这个用法和C++里的隐式this应该是一样的。

    调用函数时,会隐式传&obj1

    obj1.print();这一句其实相当于obj1.print(&obj1);

    1. 当对象为const对象时,即const test obj1(12)时,实参的类型为const test *;当print为常量成员函数时,形参this的类型为const test * const。转换时加了个顶层const,是可以的。所以const对象可以调用const成员函数。
    2. 当对象为const对象时,即const test obj1(12)时,实参的类型为const test *;当print为非常量成员函数时,形参this的类型为test * const。转换时会丢失底层const,这是不可以的。所以const对象不可以调用非const成员函数。
    3. 当对象为非const对象时,const成员函数和非const成员函数都可以调用。分析过程类似,反正实参的类型为test *,怎么转换都不可能出现丢失底层const这种情况啦。
    展开全文
  • 常对象只能调用常函数成员 c++

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

    千次阅读 2010-01-18 16:44:00
    第一种情况:const对象调用非const成员函数class A{public: A(int N = 0); void Fun();private: int n;};A::A(int N):n(N){}void A::Fun(){ cout ;}int _tmain(int argc, _TCHAR* argv
  • const对象也可以调用const成员函数

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

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

    千次阅读 多人点赞 2019-03-24 15:07:25
    数据成员  ◆ 数据成员必须进行初始化,并且不被更新。  ◆ 数据成员在声明时赋初始值(普通数据成员也是),数据成员必须在构造函数初始化列表进行初始化;... ◆ ⭐常对象可以调用常成员函...
  • 文章目录1、简单函数形式1.1 普通函数1.2 类成员函数1.3 仿函数1.4 函数指针1.5 成员函数指针 一组执行任务的语句都可以视为一个函数,一个可调用对象。在程序设计的过程中,我们习惯于把那些具有复用性的一组语句...
  • 其实我们从直观上可以很好的理解静态成员函数能调用非静态成员变量这句话因为无论是静态成员函数还是静态成员变量,它们都是在类的范畴之中的,及在类的整个生存周期里始终只能存在一份。然而静态成员变量和...
  • C++---空指针能调用成员函数吗?

    千次阅读 2019-05-02 12:00:52
    我们知道,一个对象的指针可以调用它的成员函数和虚函数,那么如果一个指向空nullptr的指针,能调用它的成员函数和虚函数。 #include<iostream> using namespace std;; class A { public: void func1() ...
  • 1、在子类内部不能调用父类中私有的成员函数,只能调用受保护和公有的成员函数。 2、在子类外部,子类对象按照继承方式重新给父类成员函数赋予访问权限(上面是 public 继承),此时只有重新赋予的访问权限是 ...
  • 在多人开发的项目中,一些通用的工具类接口可以用静态成员函数。方便调用,并且不容易调用错误。静态成员函数不传递this指针(不-&...静态成员函数如果必须访问静态成员变量,必须通过对象来引用。...
  • c++ 常成员函数常对象

    千次阅读 多人点赞 2014-06-17 13:30:17
    先明确几个概念: 1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数
  • 引用 形式—— const 类型 &对象名或变量名 ②常对象 ...3.常对象可以调用静态成员函数常成员函数,其实也可以调友元函数 (但是这里不对每一个具体展开了,就只是为了更加明白常对象是不
  • c++指针对象调用成员函数

    千次阅读 2014-05-24 00:37:02
    c++类的指针对象调用成员函数与一般对象调用成员不同,格式分别是: 普通对象:  objectName.memberfunction(para); 指针对象:  objectName->memberfunction(para) ; or (*objectName).member...
  • this作用域是在类内部,当在类的静态成员函数中访问类的静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它...
  • C++中使用空对象指针调用成员函数

    千次阅读 2016-02-23 23:36:03
    C++中,空指针是不能够使用的,然后空对象指针有时候却能够调用成员函数。  下面定义一个简单的类: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ...
  • 为什么static成员函数访问static变量, 不能调用非static成员函数?  这个很好理解, static成员函数成员函数属于类, 独立于对象而存在, 不依赖于对象。 而static成员函数、成员变量是依赖于对象的。 ...
  • 静态成员函数的非法调用

    千次阅读 2017-09-18 14:57:57
    静态成员函数是类的函数,无需指明是某个实例对象在操作,既可以是类在调用其静态成员函数也可以是其实例对象调用。注:静态成员函数只能访问静态成员变量和静态成员函数。 2 类成员函数式成员内部的函数,同一个...
  • 静态成员函数调用

    千次阅读 2019-03-19 12:13:10
    static成员函数中没有this指针,static成员函数中拥有this指针。 对象对象之间的成员变量是相互独立的。要想共用数据,则需要使用静态成员和静态方法 静态成员变量虽然在类中,但它并不是随对象...
  • C++ - 对象模型之 成员函数调用

    千次阅读 2013-02-23 14:42:00
    C++对象模型目录 C++ - 对象模型之 编译器何时才会自行添加构造函数 C++ - 对象模型之 内存布局 ... - 对象模型之 成员函数调用 ... - 对象模型之 构造和析构函数都干了什么 ...C++ - 对象模型之 成员函数调用
  • 1、定义对话框类对象全局变量指针 CDialog *g_pDlg,同时在初始化对话框时用this指针初始化此全局...2、在非类成员函数中可以使用g_pDlg->成员函数名或变量名进行调用访问。 inet_ntoa:把IP地址转换为点分十进制
  • 引题class A{ public: void function() { cout ; } };int main() { A* pa = NULL; pa->function(); system("pause"); return 0; }C++中,空指针是不能够使用的,然而空对象指针有
  • 静态成员函数是类的函数,无需指明是某个实例对象在操作,既可以是类在调用其静态成员函数也可以是其实例对象调用。注:静态成员函数只能访问静态成员变量和静态成员函数。 2 类成员函数式成员内部的函数,同一个...
  • 在基本数据类型中有常量,类比到类类型中就是常对象,其实常量也是常对象常对象的声明方式:const类名 对象名;。常对象的数据成员不被改变,...但是普通对象也可以访问常成员函数,在访问过程中,普通对象会被视

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 641,798
精华内容 256,719
关键字:

常对象能调用非成员函数