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

    千次阅读 2007-09-06 16:04:00
    类是模型的抽象,对象是类的实体,具体存在。C中的struct只能包含数据成员;... 虽然在C++中:成员函数的参数表里没有一个专门的类对象或者对象指针,成员函数访问成员时不用对象限制,那是因为编译器的内部处理,自动

    是模型的抽象对象是类的实体,具体存在。

    C中的struct只能包含数据成员;而在C++struct等同于class,都可以包含函数成员,不同的是默认的访问属性。

     

    C中的struct一样,成员的访问必须在一个具体存在的对象上面,通过'.'访问。

     

    虽然在C++中:成员函数的参数表里没有一个专门的类对象或者对象指针,成员函数访问成员时不用对象限制,那是因为编译器的内部处理,自动帮助我们提供了一个对象指针(this)的参数;this是在调用成员函数的地方被确定,在函数内部再通过this限制成员于特定对象。

     

    区别于C:实现C++成员函数时要考虑到编译器会为代码自动增加this参数,并将没有限制在对象的成员绑定到this所指对象, this于调用处自动确定。 
    展开全文
  • C++的const类成员函数

    万次阅读 多人点赞 2013-03-04 18:00:42
    我们知道,在C++中,若一个变量声明为const类型,则试图修改该变量的值的操作都被视编译错误。例如, const char blank = ‘’;...为了保证const对象的常量性,编译器须区分不安全与安全的成员函数

            我们知道,在C++中,若一个变量声明为const类型,则试图修改该变量的值的操作都被视编译错误。例如,

    const char blank = ‘’;
    blank = ‘\n’;  // 错误

            面向对象程序设计中,为了体现封装性,通常不允许直接修改类对象的数据成员。若要修改类对象,应调用公有成员函数来完成。为了保证const对象的常量性,编译器须区分不安全与安全的成员函数(即区分试图修改类对象与不修改类对象的函数)。例如,

    const Screen blankScreen;
    blankScreen.display();   // 对象的读操作
    blankScreen.set(‘*’);    // 错误:const类对象不允许修改

            在C++中,只有被声明为const的成员函数才能被一个const类对象调用。

            要声明一个const类型的类成员函数,只需要在成员函数参数列表后加上关键字const,例如,

    class Screen {
    public:
       char get() const;
    };

            在类体之外定义const成员函数时,还必须加上const关键字,例如

    char Screen::get() const {
       return _screen[_cursor];
    }

            若将成员成员函数声明为const,则该函数不允许修改类的数据成员。例如,

    class Screen {
    public:
        int ok() const {return _cursor; }
        int error(intival) const { _cursor = ival; }
    };

            在上面成员函数的定义中,ok()的定义是合法的,error()的定义则非法。

            值得注意的是,把一个成员函数声明为const可以保证这个成员函数不修改数据成员,但是,如果据成员是指针,则const成员函数并不能保证不修改指针指向的对象,编译器不会把这种修改检测为错误。例如,

    class Name {
    public:
        void setName(const string &s) const;
    private:
        char *m_sName;
    };
    
    void setName(const string &s) const {
        m_sName = s.c_str();      // 错误!不能修改m_sName;
    
        for (int i = 0; i < s.size(); ++i) 
            m_sName[i] = s[i];    // 不好的风格,但不是错误的
    }

            虽然 m_Name 不能被修改,但 m_sName 是 char * 类型,const 成员函数可以修改其所指向的字符。

            const成员函数可以被具有相同参数列表的非const成员函数重载,例如,

    class Screen {
    public:
        char get(int x,int y);
        char get(int x,int y) const;
    };

            在这种情况下,类对象的常量性决定调用哪个函数。

    const Screen cs;
    Screen cc2;
    char ch = cs.get(0, 0);  // 调用const成员函数
    ch = cs2.get(0, 0);     // 调用非const成员函数

    小结:

    1)const成员函数可以访问非const对象的非const数据成员、const数据成员,也可以访问const对象内的所有数据成员;

    2)非const成员函数可以访问非const对象的非const数据成员、const数据成员,但不可以访问const对象的任意数据成员;

    3)作为一种良好的编程风格,在声明一个成员函数时,若该成员函数并不对数据成员进行修改操作,应尽可能将该成员函数声明为const 成员函数。

     

    参考资料:

    《C++ Primer第三版》

    《Effective C++第三版》

    展开全文
  • 在类外定义成员函数 成员函数可以在类体中直接定义。也可以在类体中只写成员函数的声明,而在类的外面进行函数定义。如: class Student { public : void display( ); //公用成员函数原型声明 private : int ...

    在类外定义成员函数

    成员函数可以在类体中直接定义。也可以在类体中只写成员函数的声明,而在类的外面进行函数定义。如:

    class Student
    {
    public :
        void display( ); //公用成员函数原型声明  
    private :
        int num;
        string name;
        char sex;
        //以上3行是私有数据成员
    };
    void Student::display( )//在类外定义display类函数  
    {
        cout<<"num:"<<num<<endl;
        cout<<"name:"<<name<<endl;
        cout<<"sex:"<<sex<<endl;
    }
    Student stud1,stud2; //定义两个类对象

    注意:在类体中直接定义函数时,不需要在函数名前面加上类名,因为函数属于哪一个类是不言而喻的。但成员函数在类外定义时,必须在函数名前面加上类名,予以限定(qualifed),” :: “是作用域限定符(field qualifier)或称作用域运算符,用它声明函数是属于哪个类的。:: 可以不跟类名,表示全局数据或全局函数(即非成员函数)。

    int month;//全局变量
    int day;
    int year;
    void Set(int m,int d,int y)
    {
        ::year=y; //给全局变量赋值,此处可省略
        ::day=d;
        ::month=m;
    }
    
    Class Tdate
    {
        public:
            void Set(int m,int d,int y) //成员函数
            {
                ::Set(m,d,y); //非成员函数
            }
        private:
            int month;
            int day;
            int year;
    }

    类函数必须先在类体中作原型声明,然后在类外定义,也就是说类体的位置应在函数定义之前,否则编译时会出错。虽然函数在类的外部定义,但在调用成员函数时会根据在类中声明的函数原型找到函数的定义(函数代码),从而执行该函数。在类的内部对成员函数作声明,而在类体外定义成员函数,这是程序设计的一种良好习惯。如果一个函数,其函数体只有2-3行,一般可在声明类时在类体中定义。多于3行的函数,一般在类体内声明,在类外定义。

    inline 成员函数

    在类体中定义的成员函数的规模一般都很小,而系统调用函数的过程所花费的时间开销相对是比较大的。调用一个函数的时间开销远远大于小规模函数体中全部语句的执行时间。为了减少时间开销,如果在类体中定义的成员函数中不包括循环等控制结构,C++系统会自动将它们作为内置(inline)函数来处理。也就是说,在程序调用这些成员函数时,并不是真正地执行函数的调用过程(如保留返回地址等处理),而是把函数代码嵌入程序的调用点。这样可以大大减少调用成员函数的时间开销。C++要求对一般的内置函数要用关键字inline声明,但对类内定义的成员函数,可以省略inline,因为这些成员函数已被隐含地指定为内置函数。如:

    class Student
    {
    public :
        void display()
        {
            cout<<"num:"<<num<<endl;cout<<"name:"
            <<name<<endl;cout<<"sex:"<<sex<<endl;
        }
    private :
        int num;
        string name;
        char sex;
    };

    其中第4行 void display( )也可以写成 inline void display(),将display函数显式地声明为内置函数。以上两种写法是等效的。对在类体内定义的函数,一般都省写inline。应该注意的是,如果成员函数不在类体内定义,而在类体外定义,系统并不把它默认为内置(inline)函数,调用这些成员函数的过程和调用一般函数的过程是相同的。如果想将这些成员函数指定为内置函数,应当用inline作显式声明。如:

    class Student
    {
        public : inline void display( );//声明此成员函数为内置函数
        private :
        int num;
        string name;
        char sex;
    };
    
    inline void Student::display( ) // 在类外定义display函数为内置函数
    {
        cout<<"num:"<<num<<endl;cout<<"name:"<<name<<endl;cout<<"sex:"<<sex<<endl;
    }

    值得注意的是,如果在类体外定义inline函数,则必须将类定义和成员函数的定义都放在同一个头文件中(或者写在同一个源文件中),否则编译时无法进行置换(将函数代码的拷贝嵌入到函数调用点)。但是这样做,不利于类的接口与类的实现分离,不利于信息隐蔽。虽然程序的执行效率提高了,但从软件工程质量的角度来看,这样做并不是好的办法。只有在类外定义的成员函数规模很小而调用频率较高时,才将此成员函数指定为内置函数。

    展开全文
  • 成员函数2. 构造函数2.1 如何定义2.2 如何使用2.3 还有一种写法2.4 示例:创建链表节点3. 与类的区别 1. 成员函数 示例,利用成员函数初始化成员数据: struct Students { // 这是普通成员数据 string name; int ...

    写在前面:大家好K。首先为你点进这篇有趣的文章点赞👍!文章在撰写过程中难免有疏漏和错误,欢迎你在下方留言指出文章的不足之处;如果觉得这篇文章对你有用,也欢迎你点赞和留下你的评论。更多内容请点进👉我的博客K。👈阅览。

    1. 成员函数

    示例,利用成员函数初始化成员数据:

    struct Students {
    	// 这是普通成员数据
    	string name;
    	int age;
    	// 下面定义成员函数,修改成员数据值
    	void set(string name, int year) {
    		// 形参与成员数据同名时,用this->访问成员数据
    		this->name = name;
        	age = year;
      	}
    };
    
    // 某函数中
    Students stu;
    stu.set("jkz", 18); // 调用成员函数
    cout << stu.name << ' ' << endl; // 输出:jkz
    

    利用成员函数初始化数据成员,若形参名与成员数据名相同时,用this关键字,this是指向本身的指针,所以访问成员数据用->

    2. 构造函数

    结构::{}

    示例

    struct Students {
    	string name;
    	int age;
    };
    

    在没有手动初始化值时,两个成员变量默认值为null和0。如果想自定义初始化的值,该如何做呢?

    2.1 如何定义

    struct Students {
    	string name;
    	int age;
    	int grade;
    	Students(string name, int score) : age(18), grade(score) {
    		this->name = name; // 注意用"->"访问成员变量
    	}
    	// 构造函数可以重载(形参列表不同)
    	Students(): name("jkz"), age(18), grade(100) {} // {}不能丢掉
    };
    

    类似于成员函数,但是在初始化成员方面,构造函数显然更方便。

    注意:

    1. 构造函数冒号的左边和构造函数相同,名字与结构体名相同,还有一个形参列表

    2. 如果形参名与成员变量名不同,则可以用成员变量名(形参名)(示例grade变量),多个成员用逗号分割。如果形参名与成员变量名相同,则用{this->成员变量名=形参名;}(示例name变量)来初始化,注意用“->”访问成员变量

    3. 可以直接用变量名(值)(示例name变量)直接给变量赋值

    4. {}一定要有,即使没有用到this来初始化变量,也要加上{}

    5. 形参列表可以为空,然后用第3点的方法初始化变量

    6. 若无构造函数,系统会赠送初始值

    7. this是指向本身的指针,所以访问成员变量用->

    8. 构造函数可以重载

    2.2 如何使用

    // 在某函数中
    // 若构造函数形参列表可以为空
    // 用Students stu;
    Students stu("jkz", 100);
    cout << stu.name << ' ';
    cout << stu.age << ' ';
    cout << stu.grade << endl;
    // 输出
    // jkz 18 100
    

    定义时,结构体变量名后跟是参列表

    像正常访问结构体成员一样访问

    注意:若初始化形参列表为空,那么在定义结构体变量时,不加(),只需要结构体名 变量名

    可以使用new运算符在堆区创建对象(点击学习内存4区

    2.3 还有一种写法

    结构:结构体名(){函数体}

    这种写法,形参列表必须为空,不推荐用

    2.4 示例:创建链表节点

    创建链表节点必须用new运算符来避免内存错误,点击学习悬垂指针

    // 定义结构体
    struct ListNode {
    	int val;
    	ListNode *next;
    	ListNode(int x) : val(x), next(NULL) {}
    };
    
    // 在别的地方使用
    // 创建节点
    // 必须使用new运算符使用堆区空间,以免产生内存错误
    ListNode* h = new ListNode(值域的值)
    
    // 修改值域,连接新节点
    h->next = new ListNode(值域的值)
    
    // 往后移动节点
    h = h->next
    
    // 其他操作……
    

    3. 与类的区别

    C++中的类和java中的类具有较大差别

    1. 结构体关键字struct,类关键字class
    2. 结构体声明通常不包括 public 或 private 的访问修饰符。
    3. C++中类的成员变量,默认是私有的;结构体中的数据成员是公共的,可以被直接访问
    4. 尽管结构体可以包含成员函数,但很少这样做。所以,通常情况下结构体声明只会声明成员变量。(为了读懂别人的代码和老代码,也要学习结构体成员函数)
    展开全文
  • 成员函数:类型说明符 函数名(参数表) const 如:void showDate() const 1.常成员函数可以访问常数据成员,也可访问普通数据成员。 2.常数据成员可以被常成员函数访问,也可被普通成员函数访问。 3.如果将一个...
  • 普通成员函数和静态成员函数

    千次阅读 2018-03-25 19:47:25
    类成员包括数据成员和成员函数。 两者区别 1分配内存的时间不同 静态成员属于类本身,不属于具体类对象,在类加载时分配内存空间,程序结束时才消失。可以类名直接访问。 普通成员属于类对象,在类对象创建...
  • 类有成员变量和成员函数。而函数中,不是任何一个类的成员的函数,就是非成员函数。例如: class A{ public:  void f1(){}; // 这个就是成员函数。  void f2(); // 这个也是成员函数声明,其实现在类的...
  • C++ 类成员函数的函数指针

    万次阅读 多人点赞 2018-08-23 18:40:17
    当我们在 C++ 中直接像 C 那样使用类的成员函数指针时,通常会报错,提示你不能使用非静态的函数指针: reference to non-static member function must be called 两个解决方法: 把非静态的成员方法改成静态的...
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。 1、 非const成员函数中的隐式参数:classA* this 2、 const成员函数中的隐式参数:const classA* this 根本原因: 1、 const对象的指针为const ...
  • C++普通函数,普通成员函数、静态成员函数的区别

    千次阅读 多人点赞 2017-05-13 22:24:53
    1普通函数:属于全局函数,不受具体类...普通成员函数本质上是一个包含指向具体对象this指针的普通函数,即c++类的普通成员函数都隐式包含一个指向当前对象的this指针。 例如:定义一个类: class myClass { publi
  • 成员函数:无论静态函数还是非静态函数,都是属于类的(这一点与数据成员的静态非静态不同),对象并不拥有函数的拷贝.两者的区别在于:非静态的函数由类对象(加.或指针加-&gt;;)调用,这时将向函数传递this指针.而静态...
  • 介绍C++中静态成员函数与费静态成员函数的区别。
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • 1 常成员函数 1.1声明:函数名(形参列表)const; 1.2说明: 1)const是函数类型的一部分,在实现部分也要带上该关键字; 2)const关键字可以用于对重载函数的区分; 3)常成员函数不能更新类的成员变量,也不...
  • C++中,静态成员函数不能被声明为virtual函数。  例如,下面的程序会编译失败。 #include&lt;iostream&gt; class Test { public: // 编译错误:static成员函数不能声明为virtual virtual static ...
  • (3) 重载运算符: 作为成员函数还是非成员函数 对于很多运算符来说,可以选择使用成员函数或非成员函数来实现运算符重载。 一般来说,非成员函数应是友元函数,这样它才能直接访问类的私有数据。 例如,Time类的...
  • 成员函数与非成员函数的区别

    千次阅读 2013-04-23 15:28:59
    今天看书关于成员函数和非成员函数被搞得晕头转向的,在群里问了一下大神们才搞懂是什么意思,其实简单来说成员函数是在类中定义的函数,而非成员函数就是普通函数,就是不是在类中定义的函数,其中非成员函数比较...
  • 在多人开发的项目中,一些通用的工具类接口可以用静态成员函数。方便调用,并且不容易调用错误。静态成员函数不传递this指针(不能-&gt;),不识别对象个体,所以经常用于对静态数据成员进行操作。不能操作非静态...
  • 1. 运算符重载定义为类成员函数 2. 运算符重载定义为非成员函数
  • 什么是类的成员函数和非成员函数

    千次阅读 2015-03-23 13:10:38
    类有成员变量和成员函数。而函数中,不是任何一个类的成员的函数,就是非成员函数。例如: class A{ public:  void f1(){}; // 这个就是成员函数。  void f2(); // 这个也是成员函数声明,其实现在类的...
  • 例如私有的成员函数只能被本类中的其它成员函数所调用,而不能被类外调用。成员函数可以访问本类中任何成员(包括私有的和公用的),可以引用在本作用域中有效的数据。 一般的做法是将需要被外界调用的成员函数指定为...
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数。 友元函数: 友元...
  • 普通成员函数是最一般的方法,即 class Foo: def plain_func(): pass 类成员函数是 class Foo: @classmethod def class_func(): pass 静态函数是 class Foo: @staticmethod def static_func(): pass ...
  • 类的成员函数(简称类函数)是函数的一种,它的用法和作用和前面介绍过的函数基本上是一样的,它也有返回值和函数类型,它与一般函数的区别只是:它是属于一个类的成员,出现在类体中。它可以被指定为private(私有的...
  • 静态成员函数访问构造函数

    千次阅读 2017-04-08 00:16:27
    C++中,静态成员函数可以访问静态成员变量和静态成员函数,因为类的非静态成员函数会传入一个隐藏的this指针,这是大家都知道的。非静态的成员函数是属于类的,不属于某个对象,所以不含有this指针,所以只能调用...
  • 成员函数:无论静态函数还是非静态函数,都是属于类的(这一点与数据成员的静态非静态不同),对象并不拥有函数的拷贝.两者的区别在于:非静态的函数由类对象(加.或指针加->;)调用,这时将向函数传递this指针.而静态函数由...
  • 静态成员函数访问非静态成员

    万次阅读 2019-08-12 21:47:52
    有时候我们必须要使用静态成员函数, 比如把静态成员函数的指针传递到别的模块,以实现回调函数的机制,这个时候若不使用普通函数,则必须使用静态成员函数。 这时候我们有可能需要本类的非静态成员,具体做法很...
  • 成员函数不能调用非常成员函数:比如:#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....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,912
精华内容 49,964
关键字:

成员函数