精华内容
下载资源
问答
  • C++ 常成员函数

    千次阅读 多人点赞 2017-04-26 09:29:26
    C++ 常成员函数

        常常把对象的成员函数分为两类:修改对象状态的成员函数、获取对象状态的成员函数。

        常成员函数就是一种获取对象状态的成员函数,并且不能改变对象的状态(也就是不能修改对象的成员的值)。

        形式:

    class A
    { ...
       void f() const {...}
    }

        或

    class A
    {...
        void f() const;//声明
    }
    void A::f() const //定义
    {
        ...
    }	

        当时要注意下面两个例子:

        

    class A
    {
        int x;
        char *p;
      public:
        ...
        void f() const
        {
            x=10; //Error
            p = new char[20]; //Error
        }
    }
        
    class A
    {
        int x;
        char *p;
      public:
        ...
        void f() const
        {
            strcpy(p,"abc");//没有改变p的值,因此编译程序认为OK
            *p = 'A';//同上
        }
    }

        这样的问题就需要程序设计者自己来把握了!!!


    展开全文
  • C++常成员函数

    千次阅读 2018-09-28 20:09:13
    (3)常成员函数不能更新类的成员变量,也不能调用该类中没有用const修饰的成员函数,只能调用常成员函数。 A、通过例子来理解const是函数类型的部分,在实现部分也要带该关键字。 #include ...

    声明:<类型标志符>函数名(参数表)const;

    说明:

    (1)const是函数类型的一部分,在实现部分也要带该关键字。

    (2)const关键字可以用于对重载函数的区分。

    (3)常成员函数不能更新类的成员变量,也不能调用该类中没有用const修饰的成员函数,只能调用常成员函数。

    A、通过例子来理解const是函数类型的一部分,在实现部分也要带该关键字。

    #include <iostream.h>
    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");
    
    }

     

    展开全文
  • 我们知道,类的常成员函数尾部加了const关键字,而且,声明和定义处必须都加const关键字。 举例子说明: //a.h class A { public: A(){} ~A(){} void display() const; }; //a.cpp #include "a.h" ...

    我们知道,类的常成员函数 尾部 加了 const 关键字,而且,声明 和 定义处 必须 都加 const 关键字。

    举个例子说明:

    //a.h

    class A

    {

    public: 

           A(){}

           ~A(){}

          void display() const;

    };

    //a.cpp

    #include "a.h"

    #include <iostream>

    void A::display() const

    {

         std::cout << "haha" << "\n";

    }

    此文,主要说明 为什么声明 和 定义处必须 都加的问题,其他若有看不懂的地方,建议多翻翻书。

    答: 我们知道,函数的声明 和 定义 必须匹配,而 如下两个函数是 2个 不同的函数,

             举例:

                        void display();

                        void display() const;

             若在 类的 成员函数 声明处 尾部加了 const,为了匹配, 类外定义处也必须加 const 关键字!!!

     

    总结: 这个问题的回答,一句话,为了函数匹配,所以,两处都加 const(常成员函数),或者 两处都不加const(非常成员函数)。

     

     

     

    展开全文
  • 通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。 友元的正确使用能提高程序的运行...
    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。
    

    友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差。

    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。

    友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差。

    友元函数 :

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:

    friend 类型 函数名(形式参数);
    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    友元函数的调用与一般函数的调用方式和原理一致。


    友元类 :
    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:
    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    1: #include <iostream>
    2: using namespace std;
    3:
    4: class Radius
    5: {
    6: friend class Circle; //声明Circle为Radius的友元类
    7: friend void Show_r(Radius &n); //声明Show_r为友元函数
    8: public:
    9: Radius(int x)
    10: {
    11: r = x;
    12: }
    13: ~Radius()
    14: {
    15: }
    16:
    17: private:
    18: int r;
    19: };
    20:
    21: void Show_r(Radius &n)
    22: {
    23: cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r
    24: }
    25:
    26: class Circle
    27: {
    28: public:
    29: Circle() {}
    30: ~Circle(){}
    31: double area(Radius a)
    32: {
    33: s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r
    34: return s;
    35: }
    36: private:
    37: double s;
    38: };
    39:
    40: int main(int argc, char *argv[])
    41: {
    42: Radius objRadius(9);
    43: Circle objCircle;
    44:
    45: Show_r( objRadius );
    46: cout<<"面积为:"<<objCircle.area(objRadius)<<endl;
    47:
    48: return 0;
    49: }
    被声明两个类的友元声明

    如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

    1: class Window; // 只声明
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend bool is_equal( Screen &, Window & );
    8:
    9: // ...
    10:
    11: };
    12:
    13: class Window
    14:
    15: {
    16:
    17: friend bool is_equal( Screen &, Window & );
    18:
    19: // ...
    20:
    21: };
    作为一个类的函数又是另一个类的友元

    如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元,则成员函数声明和友元声明如下:

    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: public:
    8:
    9: // copy 是类 Screen 的成员
    10:
    11: Screen& copy( Window & );
    12:
    13: // ...
    14:
    15: };
    16:
    17: class Window
    18:
    19: {
    20:
    21: // copy 是类 Window 的一个友元
    22:
    23: friend Screen& Screen::copy( Window & );
    24:
    25: // ...
    26:
    27: };
    只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

    例如如果Screen 类必须把Window 类的成员函数声明为友元,而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢?在这种情况下可以把整个Window类声明为Screen 类的友元。

    例如:



    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend class Window;
    8:
    9: // ...
    10:
    11: };
    Screen 类的非公有成员现在可以被Window 的每个成员函数访问。

    使用友元类时注意:
    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明友元函数 :

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:

    friend 类型 函数名(形式参数);
    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    友元函数的调用与一般函数的调用方式和原理一致。


    友元类 :
    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:
    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    1: #include <iostream>
    2: using namespace std;
    3:
    4: class Radius
    5: {
    6: friend class Circle; //声明Circle为Radius的友元类
    7: friend void Show_r(Radius &n); //声明Show_r为友元函数
    8: public:
    9: Radius(int x)
    10: {
    11: r = x;
    12: }
    13: ~Radius()
    14: {
    15: }
    16:
    17: private:
    18: int r;
    19: };
    20:
    21: void Show_r(Radius &n)
    22: {
    23: cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r
    24: }
    25:
    26: class Circle
    27: {
    28: public:
    29: Circle() {}
    30: ~Circle(){}
    31: double area(Radius a)
    32: {
    33: s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r
    34: return s;
    35: }
    36: private:
    37: double s;
    38: };
    39:
    40: int main(int argc, char *argv[])
    41: {
    42: Radius objRadius(9);
    43: Circle objCircle;
    44:
    45: Show_r( objRadius );
    46: cout<<"面积为:"<<objCircle.area(objRadius)<<endl;
    47:
    48: return 0;
    49: }
    被声明两个类的友元声明

    如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

    1: class Window; // 只声明
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend bool is_equal( Screen &, Window & );
    8:
    9: // ...
    10:
    11: };
    12:
    13: class Window
    14:
    15: {
    16:
    17: friend bool is_equal( Screen &, Window & );
    18:
    19: // ...
    20:
    21: };
    作为一个类的函数又是另一个类的友元

    如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元,则成员函数声明和友元声明如下:

    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: public:
    8:
    9: // copy 是类 Screen 的成员
    10:
    11: Screen& copy( Window & );
    12:
    13: // ...
    14:
    15: };
    16:
    17: class Window
    18:
    19: {
    20:
    21: // copy 是类 Window 的一个友元
    22:
    23: friend Screen& Screen::copy( Window & );
    24:
    25: // ...
    26:
    27: };
    只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

    例如如果Screen 类必须把Window 类的成员函数声明为友元,而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢?在这种情况下可以把整个Window类声明为Screen 类的友元。

    例如:



    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend class Window;
    8:
    9: // ...
    10:
    11: };
    Screen 类的非公有成员现在可以被Window 的每个成员函数访问。

    使用友元类时注意:
    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否
    展开全文
  • c++ 常成员函数对象

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

    千次阅读 2010-05-28 11:13:00
    常成员函数 使用const关键字进行说明的成员函数,称为常成员函数。只有常成员函数才有资格操作常量或对象,没有使用const关键字说明的成员函数不能用来操作对象。常成员函数说明格式如下: () const; 其中,...
  • 命名空间是一个范畴,它包含类声明函数声明,常量声明和模板声明等名字空间成员。本文拟讨论如何在名字空间中声明自己的类和函数,以及如何在程序中使用它们。 在使用C++类时,如果用到命名空间,在使用的时候需要...
  • 在继承之外,在C++中一个类成员函数调用另一个类成员的方法主要有:类的组合,友元类,类的前向声明,单例模式等,下面主要讲讲这4种方法的实现 方法1:利用类的组合 组合通俗来讲就是类B有类A的属性,如声明一个...
  • 类的成员函数(简称类函数)是函数的一种,它的用法和作用和前面介绍过的函数基本上是一样的,它也有返回值和函数类型,它与一般函数的区别只是:它是属于一个类的成员,出现在类体中。它可以被指定为private(私有的...
  • C++类的数据成员和常成员函数

    千次阅读 2019-03-11 11:01:07
    数据成员 1、定义 用const修饰的数据成员 const int hour;//定义const为数据成员 ...不能采用在构造函数中对数据成员进行赋初值的方法,因为数据成员是不能被赋值的。...普通成员函数...
  • const修饰类的成员函数,则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。 解析: *const(*号)左边放,我是指针变量指向常量; const(*号)右边放,我是指针常量指向变量; const(*号...
  • 而函数中,不是任何一个类的成员的函数,就是非成员函数。例如: class A{ public:  void f1(){}; // 这个就是成员函数。  void f2(); // 这个也是成员函数声明,其实现在类的外部。 }; void A::...
  • 非常对象访问常成员函数,导致内部this指针无法访问非常成员函数,引发如下异常: rror C2662: “LinkedList::showElement”: 不能将“this”指针从“const LinkedList”转换为“LinkedList &”  实例如下: ...
  • C++中一个类成员函数调用另一个类成员的方法

    万次阅读 多人点赞 2018-10-31 23:13:01
    在C++中一个类成员函数调用另一个类成员的方法主要有:类的组合,友元类,单例模式等,下面主要讲讲这三种方法的实现 方法1:利用类的组合 组合通俗来讲就是类B有类A的属性,如声明一个Person类,再声明一个...
  • 类中的常成员函数的使用和定义

    千次阅读 2018-06-16 16:35:01
    如果只对对象进行读操作,...常成员函数声明和定义在形式上必须一致,即在函数形参列表的右括号后面加上const。//---------main.cpp------------ #include &lt;iostream&gt; using namespace std; ...
  • C++通过类及相关的封装、继承、多态和虚函数机制支持面向对象的程序设计和开发。类是类事物的抽象,它封装了描述这类事物的共同属性和行为的数据结构和方法。... 成员函数1声明; 成员函数1定义;
  • 什么是类的成员函数和非成员函数

    千次阅读 2015-03-23 13:10:38
    而函数中,不是任何一个类的成员的函数,就是非成员函数。例如: class A{ public:  void f1(){}; // 这个就是成员函数。  void f2(); // 这个也是成员函数声明,其实现在类的外部。 }; void A::...
  • 如何声明成员函数指针?

    千次阅读 2014-01-21 15:28:06
    比如: 有如下的一个类, 里面有一个成员函数 Func() class Test {  public:  int Func(void* param1, void* param2); };   如果我想定义这个成员函数的指针,改如何声明呢? 我们知道类的成员函数都隐含了一个...
  • 也可以在类体中只写成员函数声明,而在类的外面进行函数定义。如: class Student { public : void display( ); //公用成员函数原型声明 private : int num; string name; char sex; //以上3行是私有数据...
  • 首先像这样的声明void fun() const;必须是类的成员函数,不能是单独的类外部函数 其次,如果为类成员函数,他表示 (1)不能修改成员变量; (2)不能调用非const函数; (3)其他const函数可以调用它;(其他...
  • 一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数。 友元函数: 友元...
  • C++ 数据成员、常成员函数对象

    千次阅读 多人点赞 2019-01-04 23:54:51
    首先给出一个例子简单理解const修饰数据变量的基本工作原理: #include &lt;stdio.h&gt; int main() { const int a = 250; int *ptr = (int *)&amp;a; *ptr = 360; printf("*ptr = %d\n&...
  • C++一个类的成员函数作为另一个类的友元函数

    千次阅读 多人点赞 2019-04-27 18:17:07
    先上段代码。定义了两类,都有私有变量num。分别用全局函数、友元函数计算两者的和。 #include<iostream> using namespace std; class B; class A; // 此行可不加,这里加此行是因为下面举例子...
  • C++普通函数,普通成员函数、静态成员函数的区别

    千次阅读 多人点赞 2017-05-13 22:24:53
    1普通函数:属于全局函数,不受具体类...普通成员函数本质上是一个包含指向具体对象this指针的普通函数,即c++类的普通成员函数都隐式包含一个指向当前对象的this指针。 例如:定义一个类: class myClass { publi

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 297,730
精华内容 119,092
关键字:

声明一个常成员函数void