成员函数·友元函数和一般函数的区别

阅读程序:

#include <iostream>
using namespace std;
class Time
{
public:
    Time(int h,int m,int s):hour(h),minute(m),sec(s) {}
    void display1();    //display1是成员函数
    friend void display2(Time &);  //display2是友元函数
    int getHour()
    {
        return hour;
    }
    int getMinute()
    {
        return minute;
    }
    int getSec()
    {
        return sec;
    }
private:
    int hour;
    int minute;
    int sec;
};
void Time::display1()  //成员函数display1的实现,dispaly1前加Time::
{
    //以hour形式直接访问私有数据成员,实质是this->hour形式
    cout<<hour<<":"<<minute<<":"<<sec<<endl;
}
void display2(Time &t)  //友元函数dispaly2的实现,不加Time::,友元并不是类的成员
{
    //虽然不是类的成员函数,却可以用t.hour的形式直接访问私有数据成员——这就是友元
    cout<<t.hour<<":"<<t.minute<<":"<<t.sec<<endl;
}
void display3(Time &t)  //display3是一般函数,dispaly3前不加Time::
{
    //不能直接访问,只能用公共接口t.getHour()形式访问私有数据成员
    cout<<t.getHour()<<":"<<t.getMinute()<<":"<<t.getSec()<<endl;
}
int main()
{
    Time t1(10,13,56);
    t1.display1();  //成员函数这样调用:对象名.函数名()
    display2(t1);   //友员函数的调用和一般函数无异(但实现中可以不同)
    display3(t1);   //一般函数的调用
    return 0;
}

运行结果:

输入代码:

/*
 * Copyright (c) 2014, 烟台大学计算机学院
 * All rights reserved.
 * 文件名称:sum123.cpp
 * 作    者:林海云
 * 完成日期:2015年4月15日
 * 版 本 号:v2.0
 *
 * 问题描述:此项目和例子的区别在于“距离是一个点和另外一个点的距离”,不同版本在参数上有体现。
       三个版本建议分开测试,也可以如示例,放在一个程序中完成。
 * 输入描述:无
 * 程序输出:按要求点间的距离
 */
#include<iostream>
#include<Cmath>
using namespace std;
class CPoint
{
private:
    double x;  // 横坐标
    double y;  // 纵坐标
public:
    CPoint(double xx=0,double yy=0):x(xx),y(yy) {}
    double distance1(CPoint &); //参数用const CPoint &更佳
    friend double distance2(CPoint &, CPoint &) ;
    double getX()
    {
        return x;
    }
    double getY()
    {
        return y;
    }
};
double distance3(CPoint &,CPoint &) ;

double CPoint::distance1(CPoint &p)
{
    double dx,dy,d;
    dx=x-p.x;
    dy=y-p.y;
    d=sqrt(dx*dx+dy*dy);
    return d;
}
double distance2(CPoint &p1, CPoint &p2)//注意此项并没有Cpoint ,友元类的函数与定义的类不加前置名
{
    double dx,dy,d;
    dx=p1.x-p2.x;
    dy=p1.y-p2.y;
    d=sqrt(dx*dx+dy*dy);
    return d;
}
double distance3(CPoint &p1,CPoint &p2)
{
    double dx,dy,d;
    dx=p1.getX()-p2.getX();
    dy=p1.getX()-p2.getX();
    d=sqrt(dx*dx+dy*dy);
    return d;
}
int main()
{
    CPoint p1(5,8),p2(-5,10)  ;
    cout<<"1.  "<<p1.distance1(p2)<<endl;
    cout<<"2.  "<<distance2(p1,p2)<<endl;
    cout<<"3.  "<<distance3(p1,p2)<<endl;
    return 0;
}

运行结果:

时间: 2024-10-13 23:31:09

成员函数·友元函数和一般函数的区别的相关文章

友元——友元可以访问与其有好友关系的类中的私有成员。 友元包括友元函数和友元类。

简介:友元可以访问与其有好友关系的类中的私有成员.    友元包括友元函数和友元类. [1]将普通函数声明为友元函数 #include<iostream> using namespace std; class Time { public: Time(int,int,int); friend void display(Time &);//定义友元函数 private: int hour; int minute; int sec; }; Time::Time(int h,int m,int

友元函数友元类.

友元能够理解为是类的"朋友".它能够訪问类的保护和私有成员.友元的作用在于提高程序的执行效率,可是,它破坏了类的封装性和隐藏性.友元能够是一个函数,该函数被称为友元函数:友元也能够是一个类,该类被称为友元类. 一.友元函数 友元函数是在类外定义的一个函数,不是类的成员函数. 这个函数能够是普通的C++函数,或者是其它类的成员函数.即普通友元函数和友元成员函数.友元函数是定义在类外部.但须要在类体内进行说明,为了与该类的成员函数加以差别.在说明时前面加以keywordfriend.友元函

类的成员函数实现线程的回调函数

一般都是用静态函数作为线程的回调函数实现,但是总是感觉不是很顺畅,更改吧,就好像破坏了类的封装性,不改吧,访问实在是麻烦.所以,今天要做的就是让类的成员函数作为线程的回调函数存在,其中使用的一个比较特殊的结构就是 union { void ( *ThreadProc)(LPVOID pvParam); void ( student::*MemberProc)(LPVOID pvParam); } Proc; 联合类,用于转换类成员方法指针到普通函数指针 下面是一个小李子,变量名 就凑活看吧,核心

类成员函数不能作为普通函数地址传递给普通函数指针,几种解决方案

代码如下 #include <iostream> using namespace std; class A { public: int i; public: void show() { cout << "哈哈" << endl; } }; void print(void(*p)()) { (*p)(); } int main() { A a; print(a.show); return 0; } 其中,print函数的形参为一个函数指针.在编程的时候

不可或缺 Windows Native (20) - C++: 友元函数, 友元类

[源码下载] 作者:webabcd 介绍不可或缺 Windows Native 之 C++ 友元函数 友元类 示例演示友元函数, 友元类CppClass4.h #pragma once #include <string> using namespace std; namespace NativeDll { class CppClass4 { public: string Demo(); }; } CppClass4.cpp /* * 友元(friend)函数, 友元类 * * 友元函数: C+

C++开发系列-友元函数 友元类

友元函数 默认一个类的私有属性只能在该类的内部可以直接访问.友元函数申明在内的内部,实现在类的外部可以直接访问类的私有属性. class A1 { public: A1() { a1 = 100; a2 = 200; } int getA1() { return this->a1; } //声明一个友元函数 friend void setA1(A1 *p, int a1); //这个函数是这个类的好朋友 protected: private: int a1; int a2; }; void se

C++之类的成员函数的调用 vs. 普通函数的调用

首先请看下面的语句: Point3d obj; Point3d *ptr = &obj; 当使用上述指针或者对象调用成员函数Func()时,会有: obj.Func(); ptr->Func(); 上述调用的背后到底完成了一些什么呢? 假设Func函数的定义如下: Point3d Point3d::Func() const { Float a = getA(); Point3d ret; ret._x = _x/a; ret._y = _y/a; ret._z = _z/a; return

C++:类成员函数的重载、覆盖和隐藏区别?

#include <iostream> class A { public: void func() { std::cout << "Hello" << std::endl; } void func(int k) { } }; class B : public A { public: using A::func; // 把这句注释掉试试,嘿嘿 void func(int i) { } }; int main() { B b; b.func();//编译

类成员函数的重载、覆盖和隐藏区别 (C++)

这是本人第一次写博客,主要是想记录自己的学习过程.心得体会,一是可以方便以后回顾相关知识,二是可以与大家相互学习交流. 关于C++中类成员函数的重载.覆盖和隐藏区别,第一次看到这个问题是在准备找工作的时候在牛客网中(http://www.nowcoder.com/questionTerminal/266d3a6d4f1b436aabf1eff3156fed95)看到的,后来也有遇到一些题在考察这个知识点,只要理解了他们的区别,还是可以正确的解答有关这个知识点的题.看到牛客网中有大牛的解释很好,故