c++,c语言易错点之类与对象

最新推荐文章于 2022-05-28 16:51:23 发布

CodeYourBrother

最新推荐文章于 2022-05-28 16:51:23 发布

阅读量797

点赞数

分类专栏： c语言C++易错点文章标签： c++ c语言易错点之类与对象友元类友元函数

本文链接：https://blog.csdn.net/renlei0109/article/details/26575919

版权

c语言C++易错点专栏收录该内容

12 篇文章 0 订阅

订阅专栏

拷贝构造

浅赋值

#include<iostream>
#include<cstring>
using   namespace std;
class Point
{
private:
   double x, y;
   char *name;
public:
   
    Point(char *n=NULL, double x=0.0, double y=0.0);
   ~Point();
   void disp( );
};


Point::Point (char *n, double a, double b){
  x = a;  y = b;
  if(n) {
      name=new char[strlen(n)+1];
      strcpy(name,n);
  }
  else{
       name=new char[8];
       strcpy(name,"no name");
}
cout<<name<<"  constructing"<<endl;
}

Point::~Point(){
    cout<<name<<"  destructing"<<endl;
    delete [] name;
}
void  Point::disp( ){  cout<<name<<":"<<x<<","<<y<<endl;  }
int main(){
   // 定义对象
   Point p1("home",1.0,2.0);
   Point p2("school",3.0);
   Point p3 ;
   // 输出对象
   cout<<"p1=";
   p1.disp();
   cout<<"p2=";
   p2.disp();
   cout<<"p3=";
   p3.disp();
   return 0;
}

深赋值拷贝构造

#include<iostream>
#include<cstring>
using   namespace std;
class Point
{
private:
   double x, y;
   char *name;
public:

    Point(char *n=NULL, double x=0.0, double y=0.0);
   ~Point();
   void disp( );
   Point(Point &p);
};


Point::Point (char *n, double a, double b){
  x = a;  y = b;
  if(n) {
      name=new char[strlen(n)+1];
      strcpy(name,n);
  }
  else{
       name=new char[8];
       strcpy(name,"no name");
}
cout<<name<<"  constructing"<<endl;
}

Point::~Point(){
    cout<<name<<"  destructing"<<endl;
    delete [] name;
}
void  Point::disp( ){  cout<<name<<":"<<x<<","<<y<<endl;  }
Point::Point(Point &p){
    cout<<"拷贝构造"<<endl;
        x = p.x;
        y = p.y;
    if(p.name!=NULL){
        name = new char[strlen(p.name)+1];
        strcpy(name,p.name);
    }
    else{
        name = new char[8];
        name = "no name";
    }
}
int main(){
   // 定义对象
   Point p1("home",1.0,2.0);
   Point p2("school",3.0);
   Point p3 ;
   Point p4 = p1;
   // 输出对象
   cout<<"p1=";
   p1.disp();
   cout<<"p2=";
   p2.disp();
   cout<<"p3=";
   p3.disp();
   p4.disp();
   return 0;
}

2、静态成员变量初始化

对于类X的定义：
class  X { 
public：
char  ch ;
static  int s;
 };
 int X::s = 0 ;
对象a、b、c、d的定义：
voidf( )
 { X  a ,b , c , d ; }

静态数据成员初始化：

＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞

如：intX::s = 0 ;

Ø 初始化在类体外进行，而前面不加 static ；

Ø 初始化时不加该成员的访问权限控制符 public 、 protected 、 private 等；

Ø 若未在类外初始化，程序连接时会出现错误

Ø sizeof 运算符不包含静态数据成员的空间

静态函数成员

static float getAverage(); //声明静态函数成员

floatStudent::getAverage(){return sum/3;} //实现时不需要static

普通的成员函数一般都隐含了一个this指针，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针；
静态成员函数可以访问静态数据成员和访问静态成员函数，但是静态成员函数不能访问非静态成员函数和非静态数据成员；
非静态成员函数可以任意地访问静态成员函数和静态数据成员。

3、常对象和常成员的关系

常对象只能访问常成员和长函数，否则会出错

4、友元函数

1.普通的成员函数一般都隐含了一个this指针，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针；
2.静态成员函数可以访问静态数据成员和访问静态成员函数，但是静态成员函数不能访问非静态成员函数和非静态数据成员；
3.非静态成员函数可以任意地访问静态成员函数和静态数据成员。

class Line
{
 private:
   double a, b, c;             //直线为ax+by+c=0的系数
 public: 
   Line(double a=0.0, double b=0.0, double c=0.0);
   void disp( );			
   friend double distance(Point p,Line l); //声明为Line的友元
};
Line::Line(double a, double b, double c){
	this->a = a;  this->b = b;  this->c = c; 
} 		
void  Line::disp( ){  
  cout<<"线（"<<a<<"x+"<<b<<"y+"<<c<<"=0）";}

class Line
{
 private:
   double a, b, c;             //直线为ax+by+c=0的系数
 public: 
   Line(double a=0.0, double b=0.0, double c=0.0);
   void disp( );			
   friend double distance(Point p,Line l); //声明为Line的友元
};
Line::Line(double a, double b, double c){
	this->a = a;  this->b = b;  this->c = c; 
} 		
void  Line::disp( ){  
  cout<<"线（"<<a<<"x+"<<b<<"y+"<<c<<"=0）";}

double distance(Point p,Line l){
   return fabs(l.a*p.x+l.b*p.y+l.c)/sqrt(l.a*l.a+l.b*l.b);
}	
int main(){
    Point p1(1.0,2.0);
    Line l1(3.0,4.0,5.0);
    p1.disp();
    l1.disp();
    cout<<"距离为："<<distance(p1,l1)<<endl;
    return 0;
}

友元成员函数

如果一个类的成员函数是另一个类的友元函数，则称这个成员函数为友元成员函数；
通过友元成员函数，不仅可以访问自己所在类对象中的私有和公有成员，还可访问由关键字friend声明语句所在的类对象中的私有和公有成员

class Point
{
 private:
   double x, y;                  //x,y 坐标
 public: 
   Point(double x=0.0, double y=0.0);
   void disp( );
   double distance(Line l);  //声明为Point的成员
};
Point::Point (double x, double y){
	this->x = x;  this->y = y; 
} 		
void  Point::disp( ){  cout<<"点（"<<x<<","<<y<<"）";  }

class Line
{
 private:
   double a, b, c;             //直线为ax+by+c=0的系数
 public: 
   Line(double a=0.0, double b=0.0, double c=0.0);
   void disp( );
   friend double Point::distance(Line l); //声明为Line的友元
};
  Line::Line(double a, double b, double c){
	this->a = a;  this->b = b;  this->c = c;    } 		
void  Line::disp( ){ 
    cout<<“线（"<<a<<"x+"<<b<<"y+"<<c<<"=0）";}

class Line
{
 private:
   double a, b, c;             //直线为ax+by+c=0的系数
 public: 
   Line(double a=0.0, double b=0.0, double c=0.0);
   void disp( );
   friend double Point::distance(Line l); //声明为Line的友元
};
  Line::Line(double a, double b, double c){
	this->a = a;  this->b = b;  this->c = c;    } 		
void  Line::disp( ){ 
    cout<<“线（"<<a<<"x+"<<b<<"y+"<<c<<"=0）";}

友元类

当一个类作为另一个类的友元时，称这个类为友元类。
当一个类成为另一个类的友元类时，这个类的所有成员函数都成为另一个类的友元函数
友元类的声明可以放在类声明中的任何位置。
友元关系是不能传递的。类B是类A的友元，类C是类B的友元，并不表示类C是类A的友元。
友元关系是单向的。类A是类B的友元，类A的成员函数可以访问类B的私有成员和保护成员，反之，类B不是类A的友元，类B的成员函数却不可以访问类A的私有成员和保护成员。

即（当在A类中把B类声明为友元类，则可以在B中随意访问A的成员）
友元类声明的形式如下：
firiend class <友元类名>;

class Point
{
 private:
   double x, y;                  //x,y 坐标
 public: 
   Point(double x=0.0, double y=0.0);
   void disp( );
   friend class ComputeTools; //声明为Point的友元类
};
Point::Point (double x, double y){
	this->x = x;  this->y = y; 
} 		
void  Point::disp( ){  cout<<"点（"<<x<<","<<y<<"）";  }

class Line
{
 private:
   double a, b, c;             //直线为ax+by+c=0的系数
 public: 
   Line(double a=0.0, double b=0.0, double c=0.0);
   void disp( );		// 输出私有变量的成员函数
   friend class ComputeTools; //声明为Line的友元类
};
Line::Line(double a, double b, double c){
	this->a = a;  this->b = b;  this->c = c;  } 		
void  Line::disp( ){  
cout<<"线（"<<a<<"x+"<<b<<"y+"<<c<<"=0）";}

class ComputeTools{
public:
    static double distance(Point p1,Point p2); //重载点与点距离
    static double distance(Point p,Line l); //重载点与直线距离
};
double ComputeTools::distance(Point p1,Point p2){
  return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y)); 
}
double ComputeTools::distance(Point p,Line l){
   return fabs(l.a*p.x+l.b*p.y+l.c)/sqrt(l.a*l.a+l.b*l.b);
 }

int main(){
    Point p1(1.0,2.0),p2(3.0,4.0); 	
    Line l1(3.0,4.0,5.0);
    p1.disp(); 	p2.disp();
    cout<<"距离为："<<ComputeTools::distance(p1,p2)<<endl;
    p1.disp(); 	l1.disp();
    cout<<"距离为："<<ComputeTools::distance(p1,l1)<<endl;
    return 0;
}