精华内容
下载资源
问答
  • C++之类的常成员

    千次阅读 2015-02-27 10:35:12
    类的常成员包括常数据成员和常成员函数。  常数据成员  在类的成员定义中,使用修饰符const说明的数据成员称为常数据成员。常数据成员必须初始化,并且它的数值不能被更新。常数据成员是通过构造函数的成员初始...

            类的常成员与类的静态成员相似。类的常成员包括常数据成员和常成员函数。

           常数据成员

           在类的成员定义中,使用修饰符const说明的数据成员称为常数据成员。常数据成员必须初始化,并且它的数值不能被更新。常数据成员是通过构造函数的成员初始化列表进行初始化的。

           还是举例说明常数据成员:

    <span style="font-size:18px;">#include <iostream.h>
    class A 
    {
    public:
    	A(int i);//定义的构造函数
    	void Print();//函数体在类外的一般成员函数
    	const int &r;//整型常数据成员的引用
    private:
    	const int a;//一般的常数据成员
    	static const int b;//静态的常数据成员
    };
    const int A::b=15;//给静态的常数据成员赋值
    A::A(int i):a(i),r(a)//通过构造函数的初始化列表进行初始化
    {
    }
    void A::Print()//一般成员函数的函数体
    {
    	cout<<a<<","<<b<<","<<r<<endl;
    }
    void main()
    {
    	A a1(50),a2(30);//定义有参数的两个对象
    	a1.Print();//通过对象来引用成员函数
    	a2.Print();
    }</span>

    分析:(1)该程序中定义了三个常数据成员,分别为const  int  &r;    const   int   a;   static   const  int   b;

               (2)一般的常数据成员的初始化需要构造函数初始化列表进行初始化。

               (3)通过使用构造函数对两个对象进行初始化,把i赋值给a,再把a赋值给r。在这个过程中,一旦赋值就不再更新,b的数值也是被赋值后一直保持不变。因此结果为:50,15,50和30,15,30.

     

           常成员函数

           在类的成员函数中,使用const修饰符说明的成员函数称为常成员函数。在程序中,只有常成员函数才被常对象引用。常成员函数的定义格式为:<类型说明符>  <函数名>  ( <参数表>)  const 其中,在该函数的实现部分也要加const。

           举例来说明常成员函数:

    <span style="font-size:18px;">#include <iostream.h>
    class B 
    {
    public:
    	B(int i,int j)//定义的带两个参数的构造函数
    	{ b1=i;b2=j;}
    	void Print();//函数体在类外的一般成员函数
    	void Print() const;//函数体在类外的常成员函数
    private:
    	int b1,b2;
    };
    void B::Print()//一般成员函数的函数体
    {
    	cout<<b1<<";"<<b2<<endl;
    }
    void B::Print() const//常成员函数的函数体
    {
        cout<<b1<<":"<<b2<<endl;
    }
    void main()
    {
    	B bb1(12,5);//定义的一般对象
    	bb1.Print();//通过对象来引用成员函数
    	const B bb2(10,9);//定义的类的常对象,只能引用常成员函数
    	bb2.Print();
    }</span>

    分析(1)程序中出现了两个重载函数,void Print()和void Print() const。一个是一般的成员函数,后者是常成员函数。

           (2)通过调用构造函数进行对象的初始化,结果为12;5和10:9

     


     


     

           

         

    展开全文
  • 知识点1.常对象中的任何类型的数据成员(无论私有还是公有)的值都不能被改变。...常成员函数不能更改数据成员(包括常数据成员和非常数据成员)的值 知识点6.常成员函数的用处:因为常成员函数不能改...

    知识点1.常对象中的任何类型的数据成员(无论私有还是公有)的值都不能被改变。
    知识点2.常对象能调用的:
    1.公有的常成员函数
    2.构造函数
    3.公有的静态函数
    知识点3.常对象与常成员函数只有同时存在才都有意义
    知识点4.普通对象既可以调用常成员函数,也可以调用非常成员函数
    知识点5.常成员函数不能更改数据成员(包括常数据成员和非常数据成员)的值
    知识点6.常成员函数的用处:因为常成员函数不能改变数据成员的值,所以能够防止数据被误改,可以保护数据的安全
    知识点7.函数之间调用的话,常成员函数只能调用常成员函数

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

    一、const

    1、常对象只能调用常成员函数

    2、普通对象可以调用全部的成员函数包括常成员函数

    3、常方法不能调用普通方法 可以调用常方法、静态成员方法

    4、普通方法可以调用常方法

    解释:

    当一个成员函数被调用时,自动向它传递一个隐含的参数,该参数是一个指向这个成员函数所在的对象的指针。 

    在C++中,this指针被隐含地声明为: X *const this,这意味着不能给this 指针赋值;

    在X类的const成员函数中,this指针的类型为:const X* const, 这说明this指针所指向的这种对象是不可修改

    (即不能对这种对象的数据成员进行赋值操作); 

    由于this并不是一个常规变量,所以,不能取得this的地址


    二、static 

    1、静态成员函数只能访问静态成员变量

    2、静态成员变量不属于对象,而是属于整个类

    3、静态成员变量不能通过初始化列表进行初始化,必须类外初始化

    int Test::ma = 12;

    4、static修饰的成员函数没有this指针,不依赖对象,是c标准调用约定


    三、构造函数和析构函数不能声明为const

    因为:(1)对象的初始化必须经过构造函数进行初始化

     (2)析构函数要释放对象所占的资源











    展开全文
  • C++静态成员和常成员

    2018-03-03 11:10:46
    静态成员包括静态数据成员和静态函数 1.静态数据成员 类中的非静态数据成员,每一个类对象都拥有一个副本,即每一个对象的同名数据成员可以存储不同的数值,这是保证了每个对象拥有区别于其他对象的特征。 而静态...

    一丶静态成员

    静态成员包括静态数据成员和静态函数

    1.静态数据成员

    类中的非静态数据成员,每一个类对象都拥有一个副本,即每一个对象的同名数据成员可以存储不同的数值,这是保证了每个对象拥有区别于其他对象的特征。
    而静态成员是不管创建了多少个对象,他们之间只有一个副本,也就是所有对象都共享这个静态数据成员。

    静态成员的声明要是用static关键字

    class Myclass
    {
        private:
            int a,b,c;
            static int sum; //私有静态成员
    }
    Myclass p1,p2;
    //则对象p1和p2都共享静态数据成员sum

    静态数据成员初始化格式:

    <数据类型><类名>::<静态数据成员名>=<初始值>
    int Myclass::sum=32

    初始化时注意:
    1)必须在文件作用域内对静态成员进行初始化(即应在类体外对静态数据成员进行初始化)
    2)静态数据成员进行初始化时不加static关键字
    3)静态数据成员是类的成员,因此在初始化时必须使用作用域运算符(::)限定他所属的类

    2.静态成员函数

    私有的受保护的静态数据成员必须通过公有的接口进行访问,一般将这个接口定义为静态成员函数。
    静态成员函数也是属于整个类而不是属于某一个类的对象,用static关键字声明,可以在类体内定义,也可以在类体外定义,在类体外定义时,不需要加static关键字做前缀

    访问对象成员时受限制:
    静态成员函数可以直接访问类中的静态成员,但是不能直接访问类中的非静态成员,若要访问非静态成员,必须通过参数传递的方式得到相应的对象,在进行访问

    class Point
    {
        public:
             static void Display(Point& p);//声明静态成员函数,参数为类对象
        private:
             int X,Y,Z;
             static int count;//声明静态数据成员
    }
    int Point::count=0;//对静态成员进行初始化
    void Display(Point& p)//类体外定义成员函数
        {
        cout<<"该点为:"<<p.X<<","<<p.Y<<","<<p.Z<<endl;//利用类对象调用类的非静态数据成员
        cout<<"我是类体外定义的静态成员函数"
        }   
    int main()
    {
    Point p1;
    Point::Display(p1);//访问静态成员
    return 0;
    }

    静态函数可以直接访问静态成员,通过以下方式访问非静态成员:

    <类名>::<静态成员函数名><参数表>

    二丶常成员

    数据共享可能会破坏数据的安全性,因此对于即需要共享有需要放防止改变数据的应该定义为常量进行保护,以保证程序运行期间是不可改变的。使用const修饰符进行定义,常成员包括常对象,常成员函数和常数据成员。

    1.常对象
    使用const关键字修饰的对象成为常对象,定义格式如下

    <类名>const<对象名>
    或者
    const<类名><对象名>

    常对象定义时不能被更新

    class Point
    {
    public:
        Point(int a,int b):x(a),y(b){}//构造函数
    private:
        int x,y;
    }
    const Point p1(1,2);//p1为常对象,不能被更新
    

    2.常成员函数
    使用const关键字说明的成员函数成为常成员函数,格式如下:

    <返回类型><函数名>(<参数表>)const

    注意:
    常对象和一般对象可以调用常成员函数
    常对象不能调用一般成员函数
    一般对象可以调用一般函数

    例子如下:

    class Point//定义Point类
    {
    public:
        Point(int a,int b):x(a),y(b){};
        void Display()const;//定义常成员函数
        void Move();
    private:
        int x,y;
    }
    void Display()const//常成员函数
    {
        cout<<"Point:"<<x<<","<<y<<endl;
    }
    void Move()
    {
        cout<<"Point:"<<x+1<<","<<y+1<<endl;
    }
    int main(){
        Point p1(1,2);//定义一个一般对象,并进行初始化
        const Point p2(5,6);//定义一个常对象
        p1.Move();//一般对象访问一般函数
        p1.Display();//一般对象访问常函数
        p2.Display();//常对象只能访问常函数
        return 0;
    }

    3.常数据成员
    const修饰的数据成员为常数据成员,常数据成员也必须进行初始化,并且不能被更新,但是常数据成员的初始化只能用过构造函数的成员初始化列表进行初始化

    class Point
    {
    public:
        Point(int a,int b):x(a),y(b){};//构造函数
        void Print()const{cout<<x<<","<<y<<endl;}
    private:
        const int x;
        int y;
    }
    Point::Point(int a,int b):x(a),y(b){}
    int main()
    {
        Point p1(3,4);//利用构造函数的成员初始化列表对const数据成员进行初始化
        p1.Print();//一般对象调用常函数
        return 0;
    }
    展开全文
  • 对象成员

    千次阅读 2013-04-24 16:46:42
    常对象成员包括常成员函数和常数据成员。 1. 常成员函数 使用const关键字声明的函数为常成员函数,常成员函数声明格式如下: 类型 函数名(参数表) const ; 对于常对象成员需要注意以下几点: (1...
  • 传递过程中修改权限不能放大 常成员函数 使用 this指针与常成员函数 thiis指针 this指针的数据类型 常成员函数的实现机制 意义 利用编译机制防止程序员出错 尤其在函数传参时,你不知道哪天你自己脑残或者其他人维护...
  • C++从入门到放弃this指针 和 常成员函数1. this指针需要使用`this`指针的场景2. 常成员函数(cosntstruction) this指针 和 常成员函数 1. this指针 类中的成员函数(包括构造函数,析构函数)中包含有一个隐藏的当前类...
  • 1)类中的成员函数(包括构造函数、析构函数)中都隐藏一个该类类型指针参数,名为this;在成员函数中访问类中的其它成员,其本质都是this来实现的。 2)对于普通成员函数,this指向调用对象的地址;如果对于构造函数...
  • C++中(const)数据成员初始化

    千次阅读 2013-11-03 01:42:04
    在类中使用const关键字可以修饰数据成员和成员函数或对象,分别称为数据成员、常成员函数和常对象。 1常量成员 常量成员包括常数据成员、静态常数成员和常引用。常数据成员和常引用的初始化只能通过构造函数的成员...
  • 补充需要显式使用初始化列表的场景: ...一 this指针和常成员函数(常函数) 1 this指针 1)类中的成员函数(包括构造函数、析构函数)中都隐藏一个当前类类型的指针参数,名为this,在成员函数中访问类中的...
  • 这些特殊的类型的成员变量包括: a.引用 b.常量 c.静态 d.静态常量(整型) e.静态常量(非整型)  常量和引用,必须通过参数列表进行初始化。  静态成员变量的初始化也颇有点特别,是在类外初始化且不能再带有...
  • C++常量及对象、成员汇总

    千次阅读 2014-09-14 15:31:36
    到了做题阶段,发现对C++中一些常量和对象、函数等这些东西还是区分的很不好,各种乱,所以有... 首先来看左上部分的常量:包括文字、符号常量和变量。  文字常量就是一个具体的数字,如S(圆的面积)=r*r*3.14,3
  • 静态成员变量 类中,若将一个成员变量声明为static,这种成员称为静态成员变量。... 静态数据成员不属于某个对象,在为对象分配空间中不包括静态成员所占空间。 静态数据成员可以通过类名或者对象名来引用...
  • 常数成员包括常量数据成员和常成员函数 // 静态成员属于类,不属于对象 // 静态数据成员和常量数据成员被简单函数调用时与简单数据成员一致(getA) // 不同点在于 // 1,静态数据成员在外部定义使用 className::static...
  • C++ 类中特殊的成员变量(变量、引用、静态)的初始化方法有些成员变量的数据类型比较特别,它们的初始化方式也和普通数据类型的成员变量有所不同。这些特殊的类型的成员变量包括:a.引用b.常量c.静态d.静态常量...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 292
精华内容 116
关键字:

常成员包括