精华内容
下载资源
问答
  • ![图片说明]... ``` #include #include "Classfile.h" ...using namespace std;.../* run this program using the console pauser or add your own getch, system("pause") or input loop */ ...```
  • 但是 A = 2.75 * B 就不能写成这样 因为 operator *是成员函数 只有类的对象才能引用  非成员函数才能 这样写因为 A = operaotor(2.75 ,B) 但是由于大部分非成员函数 都不能访问类的数据部分 所以 引入 友元 ...
    例如 程序 表示为 A = B * 2.75可以等于A = B.operator*(2.75)
    但是 A = 2.75 * B 就不能写成这样 因为 operator *是成员函数 只有类的对象才能引用 

    A = B * 2.75这样的写法只有非成员函数才能这么写因为:
    A  = operaotor(2.75 ,B)
    但是由于大部分非成员函数 都不能访问类的数据部分 所以 引入 友元
    friend time operator *();

    不再使用 由于 operator *()函数不是成员函数 所以不需要 time::限定符 也不需要加上 friend


    关于 cout<<打印对象内容 进行重载时 

    必须使用 友元 因为如果是成员函数 time<<cout形式的
    如果是 友元函数就可以使用 cout<<time

    cout 是ostream对象
    void operator <<(ostream &os,const time & t)
    {
    }
    这个函数不能连接 
    cout<<trip<<"Tuesday"
    cout<<x<<y;

    (cout<<x)<<y;


    由于重载operator <<的返回值还是 ostream类型所以这样可以
    ostream &operator<<(ostream &os,const time &t);
    ostream:输出至屏幕上  ofstream:输出至文件
     
    展开全文
  • #include <iostream> //声明类Point using namespace std; class Point { public: ... Point(float x=0,float y=0); //有默认参数的构造函数 ...另有,将point类中重载函数写成inline就不报错了,为什么
  • 思考:为什么要定义静态数据成员? 答:如果不定义为静态数据成员,那么每个对象都分别有一个i的副本(拷贝)。但定义为静态数据成员之后,所有的对象共享有一个i的副本,就是说i在内存里就一个副本。 那么,不同...

    创建静态成员和友元的目的:
    创建静态成员主要是解决数据共享问题,而创建友元的目的是为了让某些函数访问类中的私有成员。

    1…静态数据成员
    思考:为什么要定义静态数据成员?
    答:如果不定义为静态数据成员,那么每个对象都分别有一个i的副本(拷贝)。但定义为静态数据成员之后,所有的对象共享有一个i的副本,就是说i在内存里就一个副本。
    那么,不同对象引用i,对i改变的话, 其他对象中i的值也会被改变,而且所有对象的值都是相同的。
    在引用静态数据成员时,可以不通过对象而通过类,静态数据成员在内存只有一个,而且可以通过类来引用。这是静态数据成员属于类,很明显的。
    这是实现不同对象间数据共享的一种方法。

    (1)静态数据成员在定义或说明时前面加关键字 static 。
    例: …….

    Private:
    Int a,b,c;
    Static int s
    

    ;
    (2) 静态数据成员一般在类定义外部按特定的格式进行初始化。(静态数据成员是在程序开始运行时被分配空间的,到程序结束时才释放空间,所以可以在建立对象前就可以为静态数据成员赋值)
    其格式为:
    < 数据类型 >< 类名 >::< 静态数据成员名 >=< 值 >;
    例:

    class Nclass
    {
    ……..
    private:
    static int a;
    …….
    };
    int Nclass::a=5;
    

    引用静态数据成员时,采用如下格式:
    < 类名 >::< 静态成员名 >
    (3)实例

    class Sample
    {
    	int n;
    	static int sum;
    public:
    	Sample(int x) { n = x; }
    	void add() { sum += n; }
    	void disp()
    	{
    		cout << "n=" << n << ",sum=" << sum << endl;
    	}
    };
    int Sample::sum = 0; // 静态数据成员赋初值 
    void main()
    {
    	Sample a(2), b(3), c(5);
    	a.add();
    	a.disp();
    	b.add();
    	b.disp();
    	c.add();
    	c.disp();
    }
    

    执行结果:

    n=2,sum=2
    n=3,sum=5
    n=5,sum=10
    

    可以看出
    静态数据成员有以下特点:

    1.对于非静态数据成员,每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个,静态数据成员在程序中也只有一份拷 贝,由该类型的所有对象共享访问。(也就是说,静态数据成员是该类的所有对象所共有的。)对该类的多个对象来说,静态数据成员只分配一次内存,供所有对象共 用。所以,静态数据成员的值对每个对象都是一样的,它的值可以更新;
    2.静态数据成员存储在全局数据区。静态数据成员定义时要分配空间,所以不能在类声明中定义。在该例子中,语句int Sample ::Sum=0;是定义静态数据成员;
    3. 静态数据成员和普通数据成员一样遵从public,protected,private访问规则;
    4.因为静态数据成员在全局数据区分配内存,属于本类的所有对象共享,所以,它不属于特定的类对象,在没有产生类对象时其作用域就可见,即在没有产生类的实例时,我们就可以操作它;

    2…静态成员函数:
    (1)思考:为什么要定义静态成员函数?
    答:一般这些函数都是用来对这个类进行操作的。例如,你要修改一个静态成员数据,那么需要静态成员函数。
    (2) 调用格式为: classname::static Func()
    (3)重点:静态成员函数不属于任何对象,它属于类,所以静态成员函数中没有this指针,所以在静态成员函数中,无法访问本类的非静态数据成员。
    静态成员函数既可以在类中定义,也可以在类外定义;静态成员函数在类外定义时,不需要用static前缀;

    3…类的友元:
    把friend double Distance()放入point类中,为友元函数。

    class A
    {
    private:
    int _i;
    friend class B;
    };
    class B
    {
    public:
    void fn();
    };
    

    B类是A类的友元类,则B类的所有成员函数都是A类的友元函数,B中的任何元素都可以访问A类的私有和保护成员(注意是单向的)。

      class Point
        {
        private:
        	int _x;
        	int _y;
        //public:
        	static int _count;
        public:
        	Point(int x=0, int y=0)
        		:_x(x), _y(y)
        	{
        		_count++;
        	}
        
        	~Point()
        	{
        		_count--;
        	}
        
        	static int GetCount(/*Point* pthis*/)
        		//没有this指针,
        		//在静态成员函数中,
        		//无法对本类的非静态成员进行默认访问
        	{
        		//Point p;
        		//p.SetX(10);
        		//pthis->_x = 90;
        		return _count;
        	}
    
    	//int GetX() { return _x; }        
    	//int GetY() { return _y; }
    
    	void SetX(int x)//有this指针
    	{
    		_x = x;
    	}
    
    	friend double Distance(const Point& p1, const Point& p2);
    };
    
    int Point::_count = 0;
    
    double Distance(const Point& p1, const Point& p2)
    {
    	return pow(pow((p1._x - p2._x), 2) + pow((p1._y - p2._y), 2), 0.5);
    }
    
    int main4()
    {
    //	cout << Point::_count << endl;
    
    	Point p1(7, 1), p2(9, 7);
    
    	
    	cout << Distance(p1, p2) << endl;
    	return 0;
    }
    
    展开全文
  • 【面试】C++类中的相关函数【构造,拷贝构造,析构,友元】 构造函数:值的初始化,可带参数,无返回值,可重载,可存在多个析构函数:释放对象...为什么?1)Empty():默认构造函数2)Empty(const ...

    【面试】C++类中的相关函数【构造,拷贝构造,析构,友元】

    构造函数:值的初始化,可带参数,无返回值,可重载,可存在多个

    析构函数:释放对象内存空间,无参数,无返回值,不可重载,只能存在一个

    拷贝构造函数:拷贝对象,其形参必须是引用


    1.空类会默认添加哪些东西?怎么写?空类的大小是多少?为什么?

    1)Empty():默认构造函数

    2)Empty(const Empty&):拷贝构造函数

    3)~Empty():析构函数

    4)Empty& operate=(const Empty&):赋值运算符

    空类的大小为1,因为C++要求类的每个实例必须具有独一无二的地址,编译器自动为空类分配一个字节的大小,这样保证了每个实例具有独一无二的内存地址


    2.构造函数的执行顺序?析构函数的执行顺序

    构造函数:

    1)父类构造函数,如果有多个父类,则这些父类的构造函数的调用顺序为父类在子类中出现的顺序

    2)成员类对象构造函数,如果有多个成员类,则这些成员类的构造函数调用顺序为成员类在类中被声明的顺序

    3)子类构造函数

    析构函数:

    1)子类析构函数

    2)成员类对象的析构函数

    3)父类的析构函数


    3.构造函数和析构函数中可以抛异常吗?

    不建议在构造函数中抛异常,不可以在析构函数中抛异常!

    1)在构造函数中抛异常,将会导致析构函数不被执行,会造成内存泄漏,需要手动去释放内存或者采用auto_ptr智能指针:因为构造函数中抛出异常会默认构造函数没有执行完毕,析构函数也就不会被调用,从而内存泄漏

    2)在析构函数中抛异常,异常的处理又是调用异常对象的析构函数,这样会陷入无穷的递归中,所以必须把异常封装在析构函数的内部,而不是将异常抛出去


    4.类成员的初始化方式?哪种更快?为什么?

    1)赋值初始化:在构造函数中做赋值操作,是在数据成员分配好内存空间之后再进行赋值操作

    2)列表初始化:在冒号后使用初始化列表,是在数据成员分配内存空间时就进行初始化

    列表初始化更快赋值操作会产生临时对象,临时对象的出现会降低程序效率


    5.如何阻止编译器自动生成拷贝构造函数和赋值函数并且避免被调用?

    1)将拷贝构造函数和赋值函数手动重写并且设置为privte,且只进行声明不予实现

    手动重写可以避免编译器默认生成,设置为private可以避免被外部类或子类调用,只声明不实现可以在本类的成员函数和友元函数调用时产生连接错误

    2)继承Uncopyable类

    Uncopyable类的拷贝构造函数和赋值运算符都是私有的,不会被子类调用,从而可以阻止拷贝和对象赋值

    3)手动重写并且将函数定义为deleted函数:deleted函数为禁止调用函数


    6.什么情况下会生成默认构造函数

    1)类成员含有构造函数时:为了能够调用类成员的构造函数,所以本类必须要有构造函数

    2)父类中含有构造函数时:为了能够调用父类的构造函数,所以子类必须有构造函数才能调用父类的构造函数,才能初始化父类成员

    3)类中含有虚函数时:对象的虚函数表指针需要通过构造函数进行初始化

    4)虚继承时:指向虚基类的指针要在构造函数中被初始化

    构造函数只有在被需要时才会自动生成!

    编译器生成构造函数和拷贝构造函数的情况是一样的,也就是说编译器合成拷贝构造函数也是在上面四种情况下


    7.类的析构函数什么时候会被调用?

    1)对象生命周期结束时

    2)delete指向对象的指针时,或delete指向对象的基类类型指针,而基类析构函数是虚函数时

    3)对象A是对象B的成员,B的析构被调用时,A的析构函数也会被调用


    8.为什么友元函数必须在类的内部进行声明?

    因为编译器在编译类的时候就必须知道谁可以访问类的私有部分!所以友元函数必须在类的内部进行声明,可以在类的外部进行定义!

    posted @ 2019-06-08 15:21 Y先森0.0 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • 函数

    2020-06-24 17:03:01
    虚函数是在基类中,对成员函数进行声明的,当然构造函数和友元函数都不可以声明为虚函数 声明要加virtual,但是定义的时候不用加virtual,在派生类的声明中可加可不加,最好加上吧。 virtual void name() 二。...

    一。首先说一下,虚函数咋用的

    虚函数是在基类中,对成员函数进行声明的,当然构造函数和友元函数都不可以声明为虚函数

    声明要加virtual,但是定义的时候不用加virtual,在派生类的声明中可加可不加,最好加上吧。

    virtual void name()

     

    二。为什么使用虚函数

    对呀,为什么呢

    如果我们不使用虚函数

    比如一个基类class father,其派生类class son

    那么一个基类的指针或者引用

    father *f   /father &f,

    当他指向的是一个派生类的对象的时候

    即(以引用为例)

    father &f = son s;

    假如基类一个成员函数是show(),派生类修改了其show()

    当我们调用f.show(),调用的是基类的show(),而不是派生类的

    这就叫做静态联编,即在编译的时候我们就知道调用哪个函数快了,

    但是如果show使用了虚函数的话,那么f.show调用的是派生类修改过的show,这就是动态联编,即只有在运行的时候,

    他才知道调用了哪个函数快,因为他调用的是引用指向的对象的函数,而不是引用对应的类型的函数

    这就是为什么析构函数一般会是虚函数,如果我们使用基类的引用,释放的时候,只释放了基类的引用,但是真正的对象的内存是没有被释放的,会造成内存泄漏。

    三。工作原理

    有点不清楚

     

    说是给每个对象一个指针,该指针指向一个数组,数组里存着是这些虚函数的地址,所以数组叫做虚函数表

    基类有一个指针,指向虚函数表的地址,派生类也有一个指针,他俩指的地方不一样,但是如果虚函数没有变化,里面虚函数的地址都是一样的额,如变化了,派生类指向的虚函数表里内容就发生变化

    所以每一个对象都又个指针,每次都这个虚函数表中拿到自己对应函数的地址,然后找到该函数。

    所有有些缺点对于虚函数来说:

    (1)每个对象都要增大,因为他包含了一个指针

    (2)每个类都得创建一个虚函数的地址表

    (3)每个函数调用都需要额外的时间进行在表中查找地址。

     

    四。为什么构造函数和友元函数不能位虚

    当创建派生类对象的时候,会调用派生类的构造函数啊,而不是基类的的构造函数,为什么要虚呢

    还有就是调用虚函数是在对象创建以后,来通过对象来调用的,而构造函数是来创建对象的,对象都没创建成立,怎么调用构造函,

    友元不是类的成员函数呢,所以不能虚

    展开全文
  • 注意,因为是模板类的编写,所以直接写在同一文件,不必注意.h和.cpp分离时重载运算符的声明或者友元函数的声明。 文件命名:MyArray.hpp。这里为了方便,直接把它塞进main.cpp了,如果想要使用的话分离开即可,...
  • 准备笔记 -- 虚函数

    2017-09-06 16:03:18
    为什么? 实现多态,通过指向基类的指针或引用可以访问子类中同名覆盖成员函数 如果没有定义为虚函数呢? 基类指针即使指向了子类对象(已重写该函数),调用函数仍为基类函数 所有的函数都可以定义成虚函数么?...
  • C++ 面试准备【一】

    2019-09-23 19:18:05
    为什么引用比传指针安全? 野指针 智能指针 类 空类默认成员函数 友元函数和友元类 多态与虚函数 C++多态性实现原理 动态绑定 虚函数表和虚函数指针 纯虚函数 override和final 回避虚函数机制 不能声明为虚函数的...
  • C++服务器开发

    2020-09-22 03:31:13
    四天计划 学习时候夯实基础 学习时候求甚解,用得时候可以不用理解那么深 ...3.左值引用是什么和为什么用const 自己思考 4.当私有变量,重载时候访问不到怎么办,友元函数 友元函数得作用就是使得...
  • C++基础复习

    2020-09-05 21:57:11
    this指针可以空吗类的6大默认成员函数默认构造函数初始化列表注意初始化顺序静态成员特性静态成员函数可以调用非静态成员函数吗友元函数友元类内部类C++内存分布new/delete与malloc/free的区别什么是内存泄漏,...
  • 友元函数 构造函数 static静态函数 不能用virtual关键字修饰;普通成员函数 和析构函数 可以用virtual关键字修饰; 3.virtual函数的效果 代码如下:class GrandFather{public: GrandFather() {} virtual void fu
  • 浅析c++中virtual关键字

    2015-07-17 15:01:13
    1.virtual关键字主要是什么作用? c++中的函数调用默认不适用动态绑定。要触发动态绑定,必须满足两个条件:第一,指定虚函数;第二,通过基类类型的引用或指针调用...友元函数 构造函数 static静态函数 不能用virtu
  • C++特性学习

    2014-02-24 16:26:03
    3 为什么需要友元 4 为什么需要引用类型 4.1 运算符重载 4.2 对象,结构体作为形参传递时为了避免临时变量复制 5 为什么需要复制构造函数 当类的成员函数中存在指针类型的成员变量时,需要复制构造函数(深度复制...
  • 运算符重载中的隐式转换问题

    千次阅读 2017-07-27 17:31:56
    问题描述: 谭浩强c++书中运算符重载隐式转换关于以下两句话的问题 friend Complex operator+(Complex&, Complex&); friend Complex operator+(const Complex&,const Complex &);...2为什么友元函数
  • 笔试总结(一)

    2019-10-21 17:55:27
    c++岗位基础知识 c++中函数有三种传递方式:值传递,指针传递,引用传递 描述"A小于B或小于C"的表达式: ... 简述成员函数,全局函数,和友元函数的差别 结构struct 和类class有什么区别 析构函...
  • 对virtual关键的理解需要结合其应用场景来分析。以下从多个角度来深入理解virtual关键字。 1.virtual关键字主要是什么作用? c++中的函数调用默认不适用动态绑定。要触发动态绑定,必须...友元函数 构造函数 static静
  • c++运算符重载

    2014-12-26 20:33:49
    //问题一: 为什么编译过不了, error LNK2019: 无法解析的外部符号 "class Point __cdecl operator*(int const &,class Point const &)" // (??D@YA?AVPoint@@ABHABV0@@Z),该符号在函数 _main 中被引用 // 把第一...
  • 2013-04-08

    2013-04-08 20:22:51
    1.如果未加格式限制,float f=1.0 用cout输出的结果1. 2.若不定义拷贝构造函数,则编译器自动生成一个缺省的拷贝构造函数,它可能会产生...3.成员函数,全局函数,友元函数: 成员函数:可以访问类中的所有的成员,
  • College类的所有成员函数都是Basic的友元函数,都可以访问Basic中的隐藏信息(私有成员和保护成员)。当希望一个类可以存取另一个类的私有成员时,可以将该类声明另一类的友元类。 protected:  ...
  • 友元函数。重载赋值运算符(为什么要重载赋值运算符?),重载下标运算符等等(重载运算符的一些语法规则在练习中)。 下面列出我的一些问题: 在重载运算符的时候发现了单目运算符返回的是类的引用,但是双目运算符返
  • 6.4 将模板声明为友元 6.5 模板与分离式编译 6.6 关于模板特化 6.7 输入输出迭代子的用法 6.8 bitset的简单用法 6.9 typename的用法 6.10 什么是防函数 6.11 什么引用计数 6.1 关于模板参数 模板是...
  • C/C++笔试题

    2020-06-18 11:20:18
    1.C++编译器自动类产生的四个缺省函数什么? 答:缺省的无参构造函数、缺省的拷贝构造函数、缺省的析构函数、缺省的赋值函数。 2.在类外有什么办法可以访问类的非公有成员。 答:友元、继承、公有成员函数。 3....
  • 为什么有两种类型的联编以及为什么默认为静态联编?5.虚函数的工作原理6.有关虚函数注意事项1.构造函数2.析构函数3.友元4.没有重新定义5.重新定义将隐藏方法 1. 静态联编和动态联编 程序调用函数时,将使用哪个可执行...
  • 11.6.2 转换函数和友元函数 11.7 总结 11.8 复习题 11.9 编程练习 第12章 类和动态内存分配 12.1 动态内存和类 12.1.1 复习示例和静态类成员 12.1.2 特殊成员函数 12.1.3 回到Stringbad:复制构造函数的...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 218
精华内容 87
关键字:

友元函数为什么引用