精华内容
下载资源
问答
  • 1、如果前面有protected、private、public等关键字,那么其后的所有声明沿用此关键字,直到出现另一个类似的关键字时,才更换访问属性。 2、如果在出现第一个访问域关键字之前还有变量、函数的声明,那么: class...

    参考链接

    1、如果前面有protected、private、public等关键字,那么其后的所有声明沿用此关键字,直到出现另一个类似的关键字时,才更换访问属性。
    2、如果在出现第一个访问域关键字之前还有变量、函数的声明,那么:
    class类中默认是private
    struct结构中默认是public

    展开全文
  • 用const修饰的声明数据成员称为数据成员。 变量或对象被 const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。 用const修饰的声明数据成员称为数据成员。 有两种声明形式: const int...

                                C++常数据成员精讲—const关键字


    内容提要:
    用const修饰的定义对象称为常对象;
    用const修饰的声明成员函数称为常成员函数;
    用const修饰的声明数据成员称为常数据成员。
    变量或对象被 const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。
    用const修饰的声明数据成员称为常数据成员。
    有两种声明形式:
    const int  cctwl;
    int const  cctwl;
    int cctwl  const; //这样是错误的只能有以上两种声明形式。不能省略数据类型,可以添加 public private等访问控制符。
    说明:
    1.任何函数都不能对常数据成员赋值。
    2.构造函数对常数据成员进行初始化时也只能通过初始化列表进行。
    3.常数据成员在初始化时必须赋值或称其必须初始化.
    4.如果类有多个默认构造函数必须都初始化常数据成员。
    通过下面例子来理解常数据成员以上4点。
    A、请指出下面程序的错误
    class A
    {
    private:
    int w,h;
          const int cctwl=5;  //错误一
    public:
    };
    void main()
    {   
             A a ;   //错误二   
           cout<< "sss";
             system("pause");
    }
    错误一:不能对常数据成员在类中初始化、要通过类的构造函数,只有静态常量才能这样初始化。
    错误二:没有合适的默认构造函数可用。因为有常量cctwl没有初始化必须初始化所有常数据成员。
    更正后结果如下:
    class A{
    private:
        int w,h;
        const int cctwl;
     public:
      const int cctwlcom;//常对象可以是共有私有等访问权限
      A():cctwl(5),cctwlcom(8){};//通过构造函数初始化列表初始化常成员数据。
    };
    B、多个构造函数下的常数据成员
    请指出下面程序的错误:
    class A{
    private:
        int w,h;
         const int  cctwl;
    public:
        const int cct;
        A():cctwl(5),cct(6){};
        
    A(int x,int y) //错误一    
    {
             w=x,h=y;
        }
    };
    void main()
    {
        A a ;
        A b(3,8);
        cout<< "sss";
        system("pause");
    }
    错误一:每个构造函数都要初始化常数据成员应改为
    A(int x,int y):cctwl(7),cct(8)
     {
        w=x,h=y;
     }



                                    C++常成员函数 - const 关键字

     

     

    一、常成员函数详解
    声明:<类型标志符>函数名(参数表)const;
    说明:
    (1)const是函数类型的一部分,在实现部分也要带该关键字。
    (2)const关键字可以用于对重载函数的区分。
    (3)常成员函数不能更新任何数据成员,也不能调用该类中没有用const修饰的成员函数,只能调用常成员函数和常数据成员。
    A、通过例子来理解const是函数类型的一部分,在实现部分也要带该关键字。
    class A{
    private:
        int w,h;
    public:
        int getValue() const;
        int getValue();
        A(int x,int y)
        {
            w=x,h=y;
        }
        A(){}
    };
    int A::getValue() const    //实现部分也带该关键字
    {
        return w*h; //????
    }
    void main()
    {
        A const a(3,4);
        A c(2,6);
    cout<<a.getValue()<<c.getValue()<<"cctwlTest"; 
    system("pause");
    }
    B、通过例子来理解const关键字的重载
    class A{
    private:
        int w,h;
    public:
    int getValue() const
    {
            return w*h;
        }
        int getValue(){
            return w+h;
        }
        A(int x,int y)
        {
            w=x,h=y;
        }
        A(){}
    };
    void main()
    {   
        A const a(3,4);
        A  c(2,6);
        cout<<a.getValue()<<c.getValue()<<"cctwlTest"; //输出12和8
        system("pause");
    }
    C、通过例子来理解常成员函数不能更新任何数据成员
    class A{
    private:
        int w,h;
    public:
        int getValue() const;
        int getValue();
        A(int x,int y)
        {
            w=x,h=y;
        }
        A(){}
    };
    int A::getValue() const
    {
        w=10,h=10;//错误,因为常成员函数不能更新任何数据成员
        return w*h;
    }
    int A::getValue()
    {
        w=10,h=10;//可以更新数据成员
        return w+h;
    }
    void main()
    {
         A const a(3,4);
        A  c(2,6);
        cout<<a.getValue()<<endl<<c.getValue()<<"cctwlTest";                            system("pause");
    }
    D、通过例子来理解
    1、常成员函数可以被其他成员函数调用。
    2、但是不能调用其他非常成员函数。
    3、可以调用其他常成员函数。
    class A{
    private:
        int w,h;
    public:
        int getValue() const
     {
       return w*h + getValue2();//错误的不能调用其他非常成员函数。
     }
        int getValue2()
        {
            
            return w+h+getValue();//正确可以调用常成员函数
        }
        
        A(int x,int y)
        {
            w=x,h=y;
        }
        A(){}
    };
    void main()
    {
        A const a(3,4);
        A       c(2,6);
    cout<<a.getValue()<<endl<<c.getValue2()<<"cctwlTest";                    
    system("pause");
    }

    展开全文
  • C++数据成员精讲—const关键字更多内容:...用const修饰的声明数据成员称为数据成员。 变量或对象被 const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。 用const修饰的声明数据

    C++常数据成员精讲—const关键字更多内容:http://www.cctwl.com/

    内容提要:

    用const修饰的定义对象称为常对象;

    用const修饰的声明成员函数称为常成员函数;

    用const修饰的声明数据成员称为常数据成员。

    变量或对象被 const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。

    用const修饰的声明数据成员称为常数据成员。

    有两种声明形式:

    const int   cctwl;

    int const cctwl;

    int cctwl const; //这样是错误的只能有以上两种声明形式。不能省略数据类型,可以添加 public private等访问控制符。

    说明:

    1.任何函数都不能对常数据成员赋值。
    2.构造函数对常数据成员进行初始化时也只能通过初始化列表进行。
    3.常数据成员在初始化时必须赋值或称其必须初始化.

    4.如果类有多个默认构造函数必须都初始化常数据成员。

    通过下面例子来理解常数据成员以上4点。

    A、请指出下面程序的错误

    class A

    {

    private:

    int w,h;

          const int cctwl=5; //错误一

    public:

    };

    void main()

    {   

    A a ;   //错误二   

        cout<< "sss";

         system("pause");

    }

    错误一:不能对常数据成员在类中初始化、要通过类的构造函数,只有静态常量才能这样初始化。

    错误二:没有合适的默认构造函数可用。因为有常量cctwl没有初始化必须初始化所有常数据成员。

    更正后结果如下:

    class A{

    private:

         int w,h;

         const int cctwl;

    public:

       const int cctwlcom;//常对象可以是共有私有等访问权限

      A():cctwl(5),cctwlcom(8){};//通过构造函数初始化列表初始化常成员数据。

    };

    B、多个构造函数下的常数据成员

    请指出下面程序的错误:

    class A{

    private:

         int w,h;

          const int   cctwl;

    public:

         const int cct;

         A():cctwl(5),cct(6){};

        

    A(int x,int y) //错误一    

    {

          w=x,h=y;

         }

    };

    void main()

    {

         A a ;

         A b(3,8);

         cout<< "sss";

         system("pause");

    }

    错误一:每个构造函数都要初始化常数据成员应改为

    A(int x,int y):cctwl(7),cct(8)

    {

        w=x,h=y;

     }


    原文地址:点击打开链接

    展开全文
  • static关键字声明的变量位于程序内存空间中的全局数据存储空间,所以它存在于程序整个运行期间。 static关键字用来控制变量的持续周期以及可见性,还可以唯一化的公用成员变量,减少开销。 1.在多个文件中隐藏全局...
    static关键字以及类的静态成员变量和静态成员函数

    static关键字声明的变量位于程序内存空间中的全局数据存储空间,所以它存在于程序整个运行期间。
    static关键字用来控制变量的持续周期以及可见性,还可以唯一化类的公用成员变量,减少开销。

    1.在多个文件中隐藏全局访问性,实现多个文件的全局变量可重复命名。
    /*static.cpp文件*/
    int a = 'no static';
    void print()
    {
        cout << "no static" << endl;
    }
    
    /*main.cpp文件*/
    int
    main()
    {
        extern int a;
        cout << a << endl;
        void print();
        print();
        return 0;
    }
    

    联合编译这两个文件(g++ static.cpp mian.cpp -o main.out),结果显示可以跨文件访问 extern声明的变量,以及跨文件访问函数。

    /*static.cpp文件*/
    static int a = 'no static';
    static void 
    print()
    {
        cout << "no static" << endl;
    }
    
    /*main.cpp文件*/
    int
    main()
    {
        extern int a;
        cout << a << endl;
        void print();
        print();
        return 0;
    }
    

    会出现编译错误,显示在main.cpp文件内对变量a和函数print()未定义。

    2.实现在程序整个运行期间存在

    static可以控制变量的可见范围,全局变量则不行。
    但如果将函数的局部变量声明为static,它仍然能在整个程序周期存在,但作用域和局部变量一致,在函数退出后,不能再访问它,即使它还存在。并且重复调用该函数,该局部变量不会被重新初始化。

    int 
    print()
    {
        /*重复调用此函数,a不会被重复初始化*/
        static int a = 0;
        return a++;
    }
    
    int a = 0;
    
    int
    main()
    {
        for (; a < 10; a++)
        {
            cout << a << print() << endl;
        }
        return 0;
    }
    

    上例的输出结果为

    00
    11
    22
    33
    44
    55
    66
    77
    88
    99
    
    3.static声明的变量和全局变量默认初始化为0
    4.static声明静态成员变量

    按照static关键字的特性,静态成员变量被分配到全局数据内存区,同全局变量一致,在编译时就被分配内存。所以可以在对象创建之前就可以访问静态成员变量,并且它不会随对象的销毁而释放。
    类只是描述对象的结构和功能,在实例化类之前,都不占用内存,所以通过类内部的普通成员函数和构造函数都无法初始化静态成员变量。因为static成员变量是属于类的成员,而不是属于对象的成员。所以它是该类的所有对象共有的,它的值对于所有对象都一致。

    • 静态成员变量内存位置在全局变量区,在对象中并不占用存储空间
    • 静态成员变量是属于类的成员,而不是属于对象的成员,所以静态数据成员不能在类的内部初始化。类只有实例化为对象才会分配内存,而静态变量在程序编译时就会分配内存,所以需要在类的外部像全局变量那样定义并初始化静态成员变量。
      1)类中的普通成员函数或者构造函数无法初始化静态成员变量,会报错“未定义的引用”
    class test
    {
        private:
        static int a;
        public:
        /*以下初始化是非法的*/
        void init()
        {
            a = 1;
        }
    };
    

    2)静态成员变量只能在类的外部初始化。初始化格式为:

    数据类型 类名::静态成员变量名 = 初值
    class test
    {
        private:
        static int a;
    };
    int test::a = 1;
    

    3)在对象创建之前,就可以通过类名加作用域访问符访问静态成员变量。静态成员变量并不会打破面向对象的封装。仍然服从public, private, protected的访问限制

    class test
    {
        public:
        static int a;
    };
    
    int test::a = 1;
    
    int
    main()
    {
        cout << test::a << endl;
        return 0;
    }
    
    5.静态成员函数

    static声明的成员函数为类的静态成员函数。普通的成员函数在传递参数时编译器会默认传递一个this指针,用以在多个对象时指明该函数来自于哪个对象。但是在静态成员函数中没有this指针。

    • 由于静态成员函数没有this指针,因为当有多个对象存在时,无法判断是来自于哪一个对象,对于变量的访问会产生歧义。静态成员函数与静态成员变量一样,在程序编译时就分配内存空间。而普通成员变量在实例化之后才会分配空间。所以静态成员函数无法访问类中的普通成员变量。
    class test
    {
        private:
        int b;
        public:
        static void init()
        {
            b = 1;
        }
    };
    

    在编译时会报错。

    • 在实例为对象之前,可以直接通过类加上作用域访问符调用静态成员函数
    class test
    {
      public:
      static void init()
      {
          cout << "未创建任何对象" << endl;
      }
    };
    
    int 
    main()
    {
        /*可以直接通过类调用静态成员函数*/
        test::init();
        return 0;
    }
    
    • 静态成员函数可以访问类的静态成员变量以及静态成员函数。对于非静态成员变量的访问,只能通过实例化对象通过参数传递
    class test
    {
        public:
        static int a;
        static void init(int x)
        {
            /*可以直接访问静态成员变量*/
            cout << a << endl;
            /*可以直接访问静态成员函数*/
            print();
            cout << x << endl;
        }
        static void print()
        {
            cout << 2 << endl;
        }
        int b = 3;
    };
    
    int test::a = 1;
    
    int
    main
    {
        test test1;
        /*可通过对象传参访问非静态成员变量*/
        test::init(test1.b);
        return 0;
    }
    
    /*
    输出结果为
    1
    2
    3
    */
    
    • 对于静态成员函数的定义,可以在类内部,也可以在类外部通过作用域访问符,但是在类外部定义时,如初始化静态成员变量一样,需要去掉static关键字。
    • 注意:静态成员函数虽然生存周期大于对象,但是仍然不能初始化静态成员变量。静态成员变量的初始化只能在类外部。
    展开全文
  • 一、引言 C++中成员变量有以下几种...C++中使用const关键字修饰的成员变量就是常成员变量,有两种定义方式: const int c; int const c; 需要注意的是: 1)任何函数都不可以对其值进行赋值和修改; 2)必
  • 如果某个属性为整个所共有,不属于任何一个具体对象,则采用static关键字声明为静态数据成员,例如:银行账户的利率 静态数据成员中只有一个拷贝,不占用对象的存储空间,由该的所有对象共同维护和使用 3....
  • 使用 class 关键字声明

    千次阅读 2005-12-22 13:21:00
    class使用 class 关键字声明。采用的形式为::[attributes] [modifiers] class identifier [:base-list] { class-body }[;]其中: attributes(可选) 附加的声明性信息。有关属性和属性的更多信息,请参见 17....
  • 最近在读代码的时候遇到了大量的static关键字,自己之前对于static的用法所知的也比较有限,所以就趁着这个机会将c++中static的几种用法做一下简单的总结,希望能够对于大家的学习和使用有一定的帮助作用。...
  • C++常数据成员成员函数

    千次阅读 2019-03-11 11:01:07
    一、常数据成员 1、定义 用const修饰的数据成员 const int hour;//定义const为常数据成员 2、初始化 不能采用在构造函数中对常数据成员进行赋初值的方法,因为常数据成员是不能被赋值的。 构造函数只能用...
  • 常数据成员必须进行初始化,而且只能通过构造函数的成员初始化列表的方式来进行。列表中对成员的初始化顺序,与它们在列表中的顺序无关,而与它们在中的声明顺序有关。包含常数据成员不能使用默认构造函数...
  • 【C++】 对象、常数据成员成员函数总结

    千次阅读 多人点赞 2019-03-24 15:07:25
     ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),常数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始化均可。  ◆ PS:的成员对象若要传入参数初始化,则必须在...
  • C++——类数据成员成员函数

    千次阅读 2014-01-05 20:22:24
    C++——类数据成员成员函数 C++除了有属于对象的成员——对象成员(或实例...static数据成员类声明的内部声明,在任何程序块之外定义(注意:不能在构造函数中初始化)。 class Task { public:  //……   pri
  • 住 C++常成员函数 - const 关键字 ...一、常成员函数详解 ...(3)常成员函数不能更新成员变量,也不能调用该中没有用const修饰的成员函数,只能调用常成员函数。 A、通过例子来理解cons
  • 的静态数据成员

    2017-03-14 12:27:54
    当在的外部定义静态数据成员时,不能重复static关键字,该关键字只出现在的内部的声明语句中。 静态数据成员不属于的任何一个对象,所以它们并不是在创建的对象时被定义的,这意味着它们不是由的构造函数...
  • 声明变量时加入mutable关键字,可以在const成员函数中修改该数据成员。 一个可变数据成员永远不会是const,即使它是对const对象的成员。 demo: class Screen { public: void some_member()const; ...
  • 的静态成员 采用static关键字来声明静态成员,... 用法:类名::标识符 对于静态数据成员,必须在文件作用域内采用类名限定对静态数据成员定 对于静态函数成员与静态数据成员一样用static关键字声明 ,属于整个...
  • 中函数定义和声明关键字用法

    千次阅读 2014-08-14 09:44:37
    函数的const型需要在声明和定义处都写上 关键字inline可在声明和定义的任意一处或两处都标注 ...关键字friend只能出现在定义体内,在定义体内的位置可以随意,其性质不受其声明位置的访问控制标示符控
  • C++与const关键字

    2017-03-22 00:42:00
    const 成员函数可以使用中的所有成员变量,但是不能修改它们的值,这种措施主要还是为了保护数据而设置的 2、const 成员函数也称为常成员函数。 常成员函数需要在声明和定义的时候在函数头部的结尾加上 const ...
  • C++ 类成员函数后面加 const关键字

    千次阅读 2015-10-14 10:12:30
    这是用在类成员函数的声明和定义中, 例如 在 .h中  void fun()const; 在.cpp中  void Class::fun() const  {  ....  } 作用: 表示该函数可以被常量对象调用, 例如 const ClassA a; a.fun...
  • 数据成员一般声明为private,以实现信息的隐蔽 成员函数一般声明为public,以提供外界使用的接口 构造函数一般声明为public,以便创建的对象 创建一个类型的对象时,编译器会自动使用一个构造函数来初始化该对象...
  • 因此,内部可以使用this作为前缀引用实例成员; this()代表了调用另一个构造函数,至于调用哪个构造函数根据参数表确定。this()调用只 能出现在构造函数的第一行。  当在内部中使用关键字this,指的就是内部...
  • C++中(const)常数据成员初始化

    千次阅读 2013-11-03 01:42:04
    中使用const关键字可以修饰数据成员和成员函数或对象,分别称为数据成员成员函数和对象。 1常量成员 常量成员包括常数据成员、静态常数成员和引用。常数据成员引用的初始化只能通过构造函数的成员...
  • 关键字transient是干啥的

    万次阅读 多人点赞 2018-10-31 13:16:36
    百度百科的解释:  Java语言的关键字,变量修饰符,如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。...当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制...
  • 数据成员声明前加上关键字static,该数据成员就是内的静态数据成员。 先举一个静态数据成员的例子。  //Example 5  #include class Myclass  {  public:  Myclass(int a,int b,int c); ...
  • 1.初始化列表 2.explicit关键字 3.static成员 概念: 4.友元 4.1友元函数 4.2友元
  • 理解final关键字

    万次阅读 多人点赞 2018-08-07 22:24:12
    final在Java中是一个保留的关键字,可以声明成员变量、方法、以及本地变量。一旦你将引用声明作final,你将不能改变这个引用了,编译器会检查代码,如果你试图将变量再次初始化的话,编译器会报编译错误。 一....
  • 的静态数据成员内只能声明,定义和初始化必须在外 可以这样 class a { int aa; static int aaa; //静态数据成员声明 }; int a::aaa=10; //静态数据成员的定义和初始化
  • String、StringBuffer、StringBuilder区别 1)三者底层都采用char[] value 存储值;...注:继承抽象或接口时,只要将子类声明为抽象并将对应的方法声明为抽象方法则可以不用在子类中提供具体实现。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 195,903
精华内容 78,361
关键字:

关键字声明是类的常数据成员