【C++易错点总结】类和其他对象的特性

「爱情、让人受尽委屈。」 2022-10-16 06:23 127阅读 0赞

# 静态成员 #

## 静态数据成员 ##

class Sample
    {
        
    	int a,b,c;//非静态数据成员 
    	static int d;//静态数据成员
    }s1,s2,s3;

静态数据成员的初始化必须在**类体外**进行。

int Sample::d=10;

注意  
**1、如果没有=10，那么静态数据成员的值被初始化为0。  
2、变量名前要加类名限定，指定他所属的类**

静态数据成员是类的所有对象共享的，而不是某个对象独享的，也可以说静态数据成员是属于类的。

静态数据成员的提出是为了解决对象之间的数据共享问题，一个对象给静态数据成员赋值之后，另一个对象可以读取该值。

## 静态成员函数 ##

静态成员函数和静态数据成员一样，都是属于类的，而不是属于对象的。

在类体外调用公有静态成员函数：

<类名>::<静态成员函数名> (实参列表)

C++也允许通过对象名调用公有静态成员函数

<对象名>.<静态成员函数名> (实参列表)

同理，如果将一个静态数据成员定义成共有的，在类体外可以通过一下两种方式访问

<类名>::<静态成员成员名>
    <对象名>.<静态成员成员名>

注意  
**如果静态数据成员或静态成员函数是私有的，在类体外不管是通过类名还是通过对象名都不能直接访问。**

一般成员函数内部可以访问其他静态成员，而在静态成员函数中，只能直接访问类的其他静态成员，不能直接访问类的非静态成员。如果要想在静态成员函数中访问非静态成员，可以通过参数对象来实现，具体见下例;

#include <iostream>
    using namespace std;
    
    class Sample
    {
        
        int a;
        static int b;                       	// 定义私有静态数据成员 
    public:
        static int c;                      		// 定义公有静态数据成员 
        Sample(int x) {
         a = x; b += x; }
        static void disp(Sample s)            // A，定义静态成员函数 
        {
        
            cout << "a=" << s.a << ", b=" << b << endl;  // B
        }    				// 续前行，访问非静态数据成员和静态数据成员  
    };
    
    int Sample::b = 10; 				// C，初始化静态数据成员 
    int Sample::c = 20; 				// D，初始化静态数据成员 
    
    int main()
    {
        
        Sample s1(2), s2(3);
    
        Sample::disp(s1);  		   	// E，可改写为s1.disp(s1);或s2.disp(s1);
        Sample::disp(s2);  		    // F，可改写为s1.disp(s2);或s2.disp(s2);
        cout << "c=" << Sample::c << endl;	
        // G，Sample::c 可改写为 s1.c 或 s2.c
        return 0;
    }

# 友元 #

## 友元函数 ##

类有很好的封装性和信息隐蔽性，即只有在类的成员函数中才能直接访问私有成员，在类外不能直接访问私有成员和保护成员（除非有公有函数接口）

这个时候，可以把函数定义为类的友元函数，见A行，**这样就可以在友元函数内直接访问类的私有成员。**

注意  
1、友元函数**不是类的成员函数**，所以，可以把友元函数放在类的任意段：private、protected、public

2、书写友元函数的时候前面**不用加类的限定**，直接写friend后面的东西就好。

#include <iostream>
    #include <cmath>
    using namespace std;
    
    class Point
    {
        
        int x, y;
    public:
        Point(int a = 0, int b = 0) : x(a), y(b) {
         }
        void Show() {
         cout << "Point(" << x << ',' << y << ")\n"; }
        int Getx() {
         return x; }
        int Gety() {
         return y; }
        friend double dist(Point&, Point&);                // A
    };
    
    double dist(Point &p1, Point &p2)
    {
        
        return sqrt((p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y));//B
    }
    
    int main()
    {
        
        Point p1, p2(1, 1);
    
        cout << dist(p1, p2) << endl;
        return 0;
    }

## 一个类的成员函数作为另一个类的友元函数 ##

#include <iostream>
    using namespace std;
    
    class N;     				 // A，类N的引用性说明
    
    class M
    {
        
        int a, b;
    public:
        M(int x, int y) {
         a = x; b = y; }
        void Print(){
         cout << "a=" << a << '\t' << "b=" << b << endl; }
    
        void Setab(N &); 	// B，Setab()是M类的成员函数，其参数是N类对象的引用  
    };
    
    class N
    {
        
        int c, d;
    public:
        N(int x, int y) {
         c = x; d = y; }
        void Print() {
         cout << "c=" << c << '\t' << "d=" << d << endl; }
    
        friend void M::Setab(N&);	// C，将类M的成员函数Setab()说明成本类的友元函数
    };
    
    void  M::Setab(N &obj)			// 类M的成员函数Setab( )是类N的友元函数，
    {
        
        a = obj.c;  				// D，因此在Setab( )中可直接访问类N的私有成员。
        b = obj.d;
    }
    int main( )
    {
        
        M m(25, 40);
        N n(55, 66);
    
        cout << "m: "; m.Print();
        cout << "n: "; n.Print();
        m.Setab(n);
        cout << "m: "; m.Print();
        return 0;
    }

运行结果：

m: a=25 b=40
    n: a=55 d=66
    m: a=55 b=66

## 友元类 ##

当一个类作为另外一个类的友元时，意味着这个类的所有成员函数都是另一个类的成员函数

定义友元类：

class A
    {
        
    	friend class B;
    }
    class B
    {
        
    	xxxxxxxx
    }

在B类所有成员函数中，均可以直接访问A类的私有成员

#include <iostream>
    using namespace std;
    
    class B;     // 类的引用性说明
    
    class A      // 类中默认访问权限是私有的
    {
        
        int x;
        void Disp() {
         cout << "x=" << x << endl; }   // 私有成员函数 
    
        friend B;                               			// 将B类说明成A类的友元类
    };
    
    class B
    {
        
    public:
        void Set(int n)
        {
        
            A a;
            a.x = n;     //可访问A类对象的私有数据成员x
            a.Disp();    //可访问A类对象的私有成员函数Disp( )
        }
    };
    
    int main(void)
    {
        
        B b;
        b.Set(3);
        return 0;
    }

运行结果：

x=3

# 常数据成员和常成员函数 #

## 常数据成员 ##

常数据成员的值是常量，不能被修改。

常数据成员的初始化**只能在类的构造函数的成员初始化列表**中进行。

class Point
    {
        
    	int x,y;
    	const int color;
    public:
    	Point(int a=0,int b=0,int c=0):color(c)//构造函数
    	{
        
    		x=a;
    		y=b;
    	}
    };

或者也可以写成

Point(int a=0,int b=0,int c=0):x(a),y(b),color(c){
        }

## 常成员函数 ##

定义常成员函数的方法是在函数头的尾部、参数的右括号后面加关键字

注意

1、常成员函数只能读取类的数据成员，不能修改（比如不能赋值）

2、一般成员函数（指非const成员函数）可以修改除了常数据成员其他数据成员的值

#include <iostream>
    using namespace std;
    
    class Point
    {
        
        int x;			  	// 一般数据成员
        const int y;	  		// 常数据成员
    public:
        Point(int a = 0, int b = 0) : x(a), y(b) {
         }
    
        int fun()         		// A，一般成员函数
        {
        
            x = 5;        		// 修改一般数据成员x，合法
            y = 6;        		// 修改常数据成员，	非法
            return x + y;   	// 读取x和y，		合法
        }
        int fun() const   	// B，常成员函数 
        {
        
            x = 5;        		// 修改一般数据成员x，非法
            y = 6;        		// 修改常数据成员，    非法
            return x + y;   	// 读取x和y，		合法
        }
    };

3、const参与重载函数的区分，见上例A行和B行。

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

#include <iostream>
    using namespace std;
    
    class Point
    {
        
        int x;
        const int y;
    public:
        Point(int a = 0, int b = 0) : x(a), y(b) {
         }
        int fun();
        int fun() const;  			// 类中声明有关键字const 
    };
    int Point::fun()
    {
        
        return x + y;
    }
    int Point::fun() const   		// 类外定义也必须有关键字const
    {
        
        return x - y;
    }
    int main()
    {
        
        Point p1(1, 8);
        const Point p2(1, 8);
    
        cout << p1.fun() << ',' ;	// p1调用的是第1个fun()函数
        cout << p2.fun() << endl;	// p2调用的是第2个fun()函数
        return 0;
    }

5、如果要修改某个常对象数据成员的值，可以将数据成员定义为**mutable**型

6、常成员函数只能调用长成员函数，不能调用非const成员函数。