精华内容
下载资源
问答
  • //常对象只能调用常成员函数 people::people( const people& temp) temp是常对象 temp.getname(); temp.getage(); temp调用函数 getname(), getage()。 getname(), getage()必须是常...
    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++

    千次阅读 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

    展开全文
  • c++常对象常成员函数详解

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

    常对象

    常对象是指该对象在其生命周期内,其所有的数据成员的值都不能被改变;定义对象时加上关键字const,该对象就是常对象,其一般形式如下:

    类名 const 对象名[(实参类别)];
    或者
    const 类名 对象名[(实参类别)];

    形如:const CComplex num;

    需要特别说明的是:

    1. 常对象只能调用常成员函数,不能调用普通成员函数
    (除了隐式调用析构函数和构造函数),常成员函数是常对象的唯一对外接口;
    2. 现在编译系统只检查函数的声明,只要发现调用了常对象的成员函数,而且该函数未被声明为const,编译阶段就报错
    3. 常对象在被定义时需要被初始化;

    类设计源码:

    class CComplex
    {
    public:
        //普通构造函数
        CComplex(int nReal, int nImag):m_nReal(nReal),m_nImag(nImag)
        {
            cout << "common constructor function" << endl;
        }
        int GetRealNum()
        {
            return m_nReal;
        }
    private:
        int m_nReal;
        int m_nImag;
    };
    //常对象
    const CComplex num1(1,1);
    //error:不能将“this”指针从“const CComplex”转换为“CComplex &”
    int nReal = num1.GetRealNum();

    编译错误的原因是,目前该函数还是普通函数,它可能会修改成员变量;为了常对象能调用GetRealNum函数,应该将该函数设计成常成员函数;

    形如int GetRealNum() const;

    常数据成员

    如果我们希望在创建对象后,该对象的某个数据成员就保持不变,我们可以将这个数据成员设置为常数据成员;常数据成员只能通过构造函数初始化列表进行初始化,其他形式的函数均不能进行数据的赋值;

    常成员函数

    若将成员函数设置为常成员函数,则只能引用本类中的数据成员,而不能修改它;常成员函数可以引用const数据成员,也可以引用非const的数据成员;常成员函数的一般形式为:

    类型名 函数名(形参列表) const

    这里的const关键字是函数类型的一部分,在函数声明和函数定义时都要带const关键字,否则被编译器认为是不同的两个函数,但是在函数调用的时候不必带const;

    形如:

    //声明和定义一起实现
    int GetRealNum() const
    {
       return m_nReal;
    }

    函数API设计总结

    (1) 若我们定义了一个常对象,则指向这个常对象的指针变量或者对象引用也需要是const类型的;一般形式如下:

    const 类型名* 指针变量名;
    const 类型名& 引用名;

    (2)常对象的唯一对外接口是常成员函数;
    (3)为了节约时间开销和时间开销,一般将函数形参定义为指针或者引用类型;
    (4)若不希望传入的实参对象被修改,应该将形参定义指向常对象的指针变量或者引用;

    根据以上几点知识,我们进行类设计时,最好遵循以下两点结论:

    1.将不涉及数据成员修改的函数定义为常成员函数

    形如: int GetRealNum() const

    2.当发生函数调用时,希望传入的实参对象不被修改,应当将形参定义为const类型的指针或者引用;这个实参可以是const类型的,也可以是非const类型的,函数接口兼容性更加,形如:

    static void TransByPointer(const CComplex* obj)
    {
        cout << "TransByPointer \n" << endl;
    }
    
    static void TransByRefence(const CComplex& obj)
    {
        cout << "TransByRefence \n" << endl;
    }

    下面给出const相关知识的具体调用说明:

    数据成员 非const的普通成员函数 const成员函数
    非const的普通数据成员 可以引用,也可以改变值 可以引用,但不可以改变值
    const数据成员 可以引用,但不可以改变值 可以引用,但不可以改变值
    const对象 不允许 可以引用,但不可以改变值
    展开全文
  • c++ 常成员函数常对象

    千次阅读 多人点赞 2014-06-17 13:30:17
    先明确几个概念: 1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数
  • 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...
  • 【C++】 常对象数据成员、常成员函数总结

    千次阅读 多人点赞 2019-03-24 15:07:25
    常数据成员  ◆ 常数据成员必须进行初始化,并且不能更新。  ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),常数据成员必须在构造函数初始化列表进行初始化;... ◆ ⭐常对象可以调用常成员函...
  • 一、const1、常对象只能调用常成员函数2、普通对象可以调用全部的成员函数包括常成员函数3、常方法不能调用普通方法 可以调用常方法、静态成员方法4、普通方法可以调用常方法解释:当一个成员函数被调用时,自动向它...
  • 在c++中,我们可以用const来定义一个const对象,const对象是不可以调用类中的非const成员函数,这是为什么呢?下面是我总结的一些原理。假设有一个类,名字为test代码如下: 1 class test{ 2 int i; 3 public: 4 ...
  • 常成员函数不能调用非常成员函数:比如:#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....
  • 不能通过常对象调用普通成员函数,但是可以通过普通对象调用常成员函数。常对象只能调用常成员函数。常对象的声明如下: const   const  两种声明完全一样没有任何区别。 1、通过下面例子来理解常对象: A、请...
  • 通过该对象只能调用它的常成员函数,而不能调用它的普通成员函数。以防普通成员函数会修改数据成员的值。但如果一定要修改常对象数据成员的值,可以将该数据成员声明为mutable,如: mutable int count;//把count...
  • 1.成员变量:成员变量是用关键字const来声明的变量,const位于变量前或者类型前都一样,用const修饰的变量只能...注明:常成员函数只能通过构造函数的初始化表对其进行初始化,成员变量所在类中所有的构造函数...
  • C++ 常对象常成员函数

    千次阅读 2016-10-03 09:46:52
    常对象:不能修改的对象。“只读”。使用const声明,声明时必须初始化。 格式: const 类名 对象名 (初始化列表)  类名 const 对象名 (初始化列表) const Point p(100,200);...const成员函数只能调用c
  • 引用 形式—— const 类型 &对象名或变量名 ②常对象 ...3.常对象可以调用静态成员函数常成员函数,其实也可以调友元函数 (但是这里不对每一个具体展开了,就只是为了更加明白常对象是不
  • 成员变量、常成员函数常对象

    千次阅读 2013-03-14 12:56:38
    成员变量是用关键字const来声明成员变量, const位于变量前或类型前都一样。 使用特点: (1)成员变量只能通过构造函数的初始化表对成员变量进行初始...常成员函数: 用const来修饰的成员函数 ,const位于函数的括
  • 1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数。 3. 当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含使用this...
  • 常成员函数和静态成员函数

    千次阅读 2018-03-12 19:35:51
    常成员函数具有以下特殊性质 不能更新成员变量的值(静态成员变量除外)不能调用除了常成员函数以外的成员函数可以用来区分函数重载类的常对象只能访问类的常成员函数 class A{ private: int w, h; publi...
  • 在基本数据类型中有常量,类比到类类型中就是常对象,其实常量也是常对象常对象的声明方式:const类名 对象名;。常对象的数据成员不能改变,...但是普通对象也可以访问常成员函数,在访问过程中,普通对象
  • 常成员函数中,你不能改变数据成员的值,你也不能在常成员函数调用非常量成员函数,因为你不确定你调用的那个非常量成员函数是否改变了数据成员的值,如果改变了,那就相当于在常成员函数里改变了数据成员,与...
  • 3)常成员函数不能更新类的成员变量,也不可以调用类中没有用const修饰的成员函数只能调用常成员函数,但是可以其他成员函数调用; 4)特别地:常对象只能访问类中const成员函数(除了系统自动调用的
  • 用const修饰的声明数据成员称为数据成员用const修饰的声明成员函数称为常成员函数用const修饰的定义对象称为常对象变量或对象被const修饰后其值不能更新。因此const修饰的变量或对象必须要进行初始化。(一)...
  • 1、在子类内部不能调用父类中私有的成员函数只能调用受保护和公有的成员函数。 2、在子类外部,子类对象按照继承方式重新给父类成员函数赋予访问权限(上面是 public 继承),此时只有重新赋予的访问权限是 ...
  • 非常对象访问常成员函数,导致内部this指针无法访问非常成员函数,引发如下异常: rror C2662: “LinkedList::showElement”: 不能将“this”指针从“const LinkedList”转换为“LinkedList &”  实例如下: ...
  • 数据成员: const 类型说明符 数据成员 如:const int year 常成员函数:类型说明符 函数名(参数表) const ...2.数据成员可以被常成员函数访问,也可普通成员函数访问。 3.如果将一个对象说明为一个常对象,...
  • C++中使用空对象指针调用成员函数

    千次阅读 2016-02-23 23:36:03
    C++中,空指针是不能够使用的,然后空对象指针有时候却能够调用成员函数。  下面定义一个简单的类: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ...
  • · 用const修饰的声明成员函数称为常成员函数 · 用const修饰的定义对象称为常对象 变量或对象被const修饰后其值不能更新。因此const修饰的变量或对象必须要进行初始化。 (一)用const修饰的声明数据成员称为...
  • this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 315,202
精华内容 126,080
关键字:

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