精华内容
下载资源
问答
  •  概念:以inline修饰的函数叫做内联函数,编译是C++编译器会在调用内敛函数的地方展开,没有函数压栈  的开销,内联函数提升程序运行的效率  特性:1.Inline是一种用空间换取时间的做法,省去调用函数额外开销...

    内联函数

        概念:以inline修饰的函数叫做内联函数,编译是C++编译器会在调用内敛函数的地方展开,没有函数压栈

                   的开销,内联函数提升程序运行的效率

        特性:1.Inline是一种用空间换取时间的做法,省去调用函数额外开销,所以代码很长或者有循环/递归的函数不适宜使用内联

                   2.inline对编译器而言只是一个建议,编译器会自动优化,如果定义为Inline的函数体内有循环或者递归

                      等等,编译器会自动忽略掉内联

                   3.inline必须和函数定义放在一起,才能成为内敛函数,仅仅将inline放在声明前是不起作用的

                   4.定义在类内的成员函数默认定义为内联函数

    注意:在C++中强烈建议使用const代替宏常量,使用const和内联函数在进行编译时不仅进行替换,而且还会进行参数 

               类型检测,提高程序的安全性,内联函数可以是普通函数,也可以是类的成员函数,函数式宏不能作为累的成员函数

     例子:

    class Test
    {
    public:
    	void output();
    };
    inline void Test::output()
    {
    	cout << "my" << endl;
    }

     或者直接在类内定义内联函数

     

    1.宏有什么优缺点?

    优点:1.提高了程序可毒性,同时也方便进行修改;

                2.提高了程序的运行效率,使用带参的宏定义既可以完成函数调用的功能,又能避免函数出栈与

                    入栈操作,减少系统开销,提高运行效率;

      缺点:1.由于是直接嵌入,代码相对多一点             

                 2.参数每次用于宏定义时它们都将重新求值,由于多次求值,带有副作用的参数可能会产生不可预料的结果

                 3.对带参的宏来说,由于是直接替换,不会检查参数是否合法,存在安全隐患

     

    2.宏函数和内联函数的区别

        宏和内联函数都采用了空间换时间的方法,在其调用处进行展开

        1.在预编译时期宏定义在调用处执行替换。在编译时期,内联函数在调用处展开,同时进行参数的类型检查

        2.内联函数是函数,可以像调用普通函数一样调用内联函数。宏定义需要添加很多括号防止歧义,编写复杂

        3.内联函数可以作为类的成员函数,成为类的保护成员或私有成员,当一个表达式涉及到类的保护成员或私有

           成员时,宏就不能实现了(无法将this指针放在合适的位置)

    友元:分为友元函数、友元类

    友元函数:

        友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在

        类中声明,声明需要加上friend关键字

         例子:

    class Date
    {
    	friend void PrintDate(const Date&d);
    public:
    	Date(int year, int month, int day)
    		:_year (year)
    		, _month (month)
    		, _day (day)
    	{}
    	
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    void PrintDate(const Date&d)
    {
    	cout << d._year << "_" << d._month << "_" << d._day << endl;
    }
    int main()
    {
    	Date x(2018, 9, 10);
    	PrintDate(x);
    	return 0;
    }

        特性:1.友元函数可以访问类的私有成员,但不是类的成员函数

                   2.友元函数不能用const修饰

                   3.友元函数可以在类的任何地方声明,不受访问限定符限制

                   4.一个函数可以是多个类的友元函数

                   5.友元函数的调用和普通函数的调用原理相同

    友元类:

        概念:友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员

                在A类定义friend B 说明B类是A类的友元,所以在B的成员函数中可以访问A类对象的私有成员

                也就是说,在A中定义B ,B是A的朋友,在B中可以访问A

    例子:

    class B
    {
    public:
    	B()
    		:_x(100)
    	{}
    private:
    	int _x;
    	friend class A;
    	friend void show();
    };
    class A
    {
    public:
    	A()
    		:_y(200)
    	{}
    	void show(B&b)
    	{
    		cout << b._x << endl;
    		cout << _y << endl;
    	}
    private:
    	int _y;
    
    };
    int main()
    {
    	A a;
    	B b;
    	a.show(b);
    	return 0;
    }

    使用友元优点是提高了程序的运行效率,缺点是破坏了类的封装性和隐藏性

    注意:友元关系不能继承,友元关系是单向的不具有交换性,友元关系不能传递

     

    展开全文
  • 内联函数友元

    2018-04-03 23:38:21
    内联函数 :以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数压栈开销,内联函数提升程序运行的效率 内联函数特征: 1. inline是一种以空间换时间的做法,省去调用函数额...

    内联函数 :以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数压栈开销,内联函数提升程序运行的效率

    内联函数特征:

    1. inline是一种以空间换时间的做法,省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。
    2. inline对于编译器而言只是一个建议,编译器会自动优化,如果定义为inline的函数体内有循环/递归等等,编译器优化时会忽略掉内联。
    3. inline必须函数定义放在一起,才能成为内联函数,仅将inline放在声明前是不起不作用的。
    4. 定义在类内的成员函数默认定义为内联函数。

    说道内联就不得不说宏:
    宏的优点:

    1. 增强代码的复用性。
    2. 提高性能。
    宏也有很多缺点:
    1. 不方便调试宏。(因为预编译阶段进行了替换)
    2. 导致代码可读性差,可维护性差,容易误用。

    3. 没有类型安全的检查。

    注意:

    在C++中,强制建议使用const代替宏常量,使用内联函数代替宏函数,const和内联函数在进行编译时不仅进行替换,而且还会进行参数类型检测,提高了程序的安全性。内敛函数可以是普通函数,也可以是类的成员函数;函数式宏不能作为类的成员函数

    #include <iostream>
    using namespace std;
    
    #define Swap(a, b)      \
    do{                     \
    	int tmp = a;    \
    	a = b;          \
    	b = tmp;        \
    }while(0)
    
    inline int Add(int a, int b)
    {
    	return a + b;
    }
    
    int main()
    {
    
    	int x1 = 10;
    	int x2 = 20;
    	Swap(x1, x2);
    
    	int x3 = 100;
    	int x4 = 200;
    	Swap(x3, x4);
    
    	printf("%d\n", Add(10, 20));
    
    	return 0;
    }

    友元 

    友元分为:友元函数和友元类

    友元函数:

    友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

    友元函数说明:
    友元函数可访问类的私有成员,但不是类的成员函数
    友元函数不能用const修饰
    友元函数可以在类定义的任何地方声明,不受类访问限定符限制
    一个函数可以是多个类的友元函数
    友元函数的调用与普通函数的调用和原理相同

    友元类:

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员
    友元的优缺点:
    优点:提高了程序运行效率
    缺点:破坏了类的封装性和隐藏性,在使用友元时,一定要注意场合和时机。
    注意:
    友元关系不能继承
    友元关系是单向的,不具有交换性
    友元关系不能传递

    class Date
    {
    	friend void Show(const Date& d); // 友元函数
    	friend class AA; // 友元类
    	friend ostream& operator<<(ostream& out, const Date& d);
    	friend istream& operator>>(istream& in, Date& d);
    
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    	{}
    
    	void Show() const
    	{
    		cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
    	}
    
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void Show(const Date& d)
    {
    	cout<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
    }
    
    class AA
    {
    public:
    	void Show(const Date& d)
    	{
    		cout<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
    	}
    
    	void Modift(Date& d)
    	{
    		d._year = 1990;
    	}
    };
    
    
    ostream& operator<<(ostream& out, const Date& d)
    {
    	out<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
    	return out;
    }
    
    istream& operator>>(istream& in, Date& d)
    {
    	in>>d._year;
    	in>>d._month;
    	in>>d._day;
    	return in;
    }
    
    int main()
    {
    	Date d1(2018, 3, 26);
    	Show(d1);
    
    	int i = 0;
    	cout<<i<<endl;
    
    	cin>>d1;
    	cout<<d1<<endl;
    
    	return 0;
    }

    展开全文
  • 1.内联函数:以inline修饰的函数叫内联函数,编译时c++编译器会会在调用内联函数的地方展开,没有函数压栈开销,内联函数提升程序运行的效率 2.内联函数的效率: inline是一种以空间换时间的做法,省去调用函数...

    一.内联函数

    1.内联函数:以inline修饰的函数叫内联函数,编译时c++编译器会会在调用内联函数的地方展开,没有函数压栈开销,内联函数提升程序运行的效率

    2.内联函数的效率:

    1. inline是一种以空间换时间的做法,省去调用函数额外开销,所以代码很长或者有递归/循环的函数不适宜使用内联
    2. inline对于编译器而言只是一个建议,编译器会自动优化,如果定义为inline的函数体内有循环/递归等,编译器优化时会忽略内联
    3. inline定义的函数定义放在一起,才能成为内联函数,仅将inline放在声明前是不起作用的
    4. 定义在类内的成员函数默认为内联函数(如若定义在类外,会当成破普通函数对待)

    3.宏的优缺点

    优点:

    1. 增强代码的复用性
    2. 提高性能

    缺点:

    1. 不会进行类型检测
    2. 代码膨胀(在预编译期间进行了替换)
    3. 不能调试
    4. 副作用(前置后置++)

    4.注意:在c++中,强制建议使用const代替宏常量,使用内联函数替代宏函数,const和内联函数在编译期间不仅进行替换,而且还会进行参数检测,提高了程序的安全性,内联函数可以是普通函数,也可以是类的成员函数,函数式宏不能作为类的成员函数

    
    #define MAX(a, b) (((a)>(b))? (a):(b))
    /*
    不会进行类型检测
    代码膨胀
    副作用
    不能调试
    */
    int main()
    {
    	int a = 10;
    	int b = 20;
    
    	cout<<MAX(a, ++b)<<endl;
    	return 0;
    }
    
    int Add(int left, int right);
    
    inline int Add(int left, int right)
    {
    	//Add(left, left);
    	return left + right;
    }
    
    class CInt
    {
    public:
    	CInt::CInt(int data)
    		: _num(data)
    	{}
    
    
    public:
    	int _num;
    };
    
    
    inline int Max(int left, int right)
    {
    	return left > right ? left :right;
    }
    
    int main()
    {
    	int a=10;
    	cout<<&a<<endl;
    	int b = 20;
    	int c;
    	c = Add(10, 20);
    	cout<<Max(a, ++b)<<endl;
    	CInt d(30);
    	return 0;
    }

    二.友元

    友元分为友元函数和友元类

    1.友元函数

    友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加上friend关键字

    class Date
    {
    	friend void PrintDate(const Date& d);
    public:
    	Date(int year,int month,int day)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    	{}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    
    void PrintDate(const Date& d)
    {
    	cout<<d._year <<"-"<<d._month <<"-"<<d._day<<endl;
    }
    
    int main()
    {
    	Date d(2017,1,1);
    	PrintDate(d);
    	return 0;
    }
    
    

    友元函数说明:

    • 友元函数可以访问类的私有成员,但不是类的成员函数
    • 友元函数不能用const修饰
    • 友元函数可以在类定义的任何地方声明,不受类访问限定符的限制
    • 一个函数可以是多个类的友元函数
    • 友元函数的调用原理和普通函数相同

    2.友元类:

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类非公有成员

    class Date
    {
    	friend void Show(const Date& d);//友元函数
    	friend class AA;//友元类
    	friend ostream& operator<<(ostream& out,const Date& d);
    	friend istream& operator>>(istream& in, Date& d);
    
    public:
    	Date(int year,int month,int day)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    	{}
    
    	void Show()const
    {
    	cout<<_year <<"-"<<_month <<"-"<<_day<<endl;
    }
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    
    void Show(const Date& d)
    {
    	cout<<d._year <<"-"<<d._month <<"-"<<d._day<<endl;
    }
    
    
    class AA
    {
    public:
    	void Show(const Date& d)
    	{
    		cout<<d._year <<"-"<<d._month <<"-"<<d._day<<endl;
    	}
    
    	void Modift(Date& d)
    	{
    		d._year =2019;
    	}
    };
    
    ostream& operator<<(ostream& out,const Date& d)
    {
    	out<<d._year<<"-"<<d._month <<"-"<<d._day<<endl;
    	return out;
    }
    
    istream& operator>>(istream& in, Date& d)
    {
    	in>>d._year ;
    	in>>d._month ;
    	in>>d._day ;
    	return in;
    }
    int main()
    {
    	Date d(2017,1,1);
    	Show(d);
    
    	int i=0;
    	cout<<i<<endl;
    
    	cin>>d;
    	cout<<d<<endl;
    	return 0;
    }
    

    3.友元优缺点:

    • 优点:提高了程序运行效率
    • 缺点:破坏了类的封装性和隐藏性,在使用有友元时,一定要注意场合时机

    4.注意:

    • 友元关系不能继承
    • 友元关系是单向的,不具有交换性
    • 友元关系不能传递
    展开全文
  • 如果一个函数是内联的,那么在编译时,编译器会把该函数的代码副本放置在每个调用函数的地方。 inline是一种以空间换时间的做法,省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。 ...

    1、内联函数(inline)
    如果一个函数是内联的,那么在编译时,编译器会把该函数的代码副本放置在每个调用该函数的地方。

    • inline是一种以空间换时间的做法,省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。
    • inline对于编译器而言只是一个建议,编译器会自动优化,如果定义为inline的函数体内有循环/递归等等,编译器优化时会忽略掉
      内联。
    • inline必须函数定义放在一起,才能成为内联函数,仅将inline放在声明前是不起不作用的。
    • 定义在类内的成员函数默认定义为内联函数
    class Date
    {
    public :
    void Func () // 定义在类内部默认为内联函数
    {}
    void Display ();
    private :
    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
    };
    inline void Date::Display () // 成员函数定义为内联
    {
    cout<<"year:" <<_year<< endl;
    cout<<"month:" <<_month<< endl;
    cout<<"day:" <<_day<< endl;
    }
    inline void Test() // 全局函数定义为内联
    {}

    注意;
    引入内联函数的目的是为了解决程序中函数调用的效率问题,这么说吧,程序在编译器编译的时候,编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换,而对于其他的函数,都是在运行时候才被替代。这其实就是个空间代价换时间的i节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神:

    1.在内联函数内不允许使用循环语句和开关语句;
    2.内联函数的定义必须出现在内联函数第一次调用之前;
    3.类结构中所在的类说明内部定义的函数是内联函数。

    引入内联函数的目的是为了解决程序中函数调用的效率问题,这么说吧,程序在编译器编译的时候,编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换,而对于其他的函数,都是在运行时候才被替代。这其实就是个空间代价换时间的i节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神:

    1.在内联函数内不允许使用循环语句和开关语句;
    2.内联函数的定义必须出现在内联函数第一次调用之前;
    3.类结构中所在的类说明内部定义的函数是内联函数。

    2、友元:
    类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。

    友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。

    如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字 friend

    class Box
    {
       double width;
    public:
       double length;
       friend void printWidth( Box box );
       void setWidth( double wid );
    };
    class Time
    {
    // Date是Time 的友元,所以 Date可以访问Time的所有成员。
    friend class Date;
    private :
    int _hour ;
    int _minute ;
    int _second ;
    };
    class Date
    {
    public :
    void Display ()
    {
    cout<<"year:" <<_year<< endl;
    cout<<"month:" <<_month<< endl;
    cout<<"day:" <<_day<< endl;
    // 定义为友元类后,可以访问Time类对象的所有成员
    cout<<"hour:" <<_t. _hour<<endl ;
    cout<<"minute:" <<_t. _minute<<endl ;
    cout<<"second:" <<_t. _second<<endl <<endl;
    }
    private :
    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
    Time _t ;
    };

    注意;友元一定程度上破坏了C++的封装,友元不宜多用,在恰当的地方使用友元

    3、static成员
    静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句,在创建第一个对象时,所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中,但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化,如下面的实例所示。

    class Date
    {
    public :
    Date ()
    {
    cout<<"Date ()" <<endl;
    ++ sCount;
    }
    void Display ()
    {
    cout<<"year:" <<_year<< endl;
    cout<<"month:" <<_month<< endl;
    cout<<"day:" <<_day<< endl;
    }
    // 静态成员函数
    static void PrintCount()
    {
    cout<<"Date count:" <<sCount<< endl;
    }
    private :
    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
    private :
    static int sCount; // 静态成员变量,统计创建时间个数
    };
    // 定义并初始化静态成员变量
    int Date::sCount = 0;

    静态成员函数与普通成员函数的区别:

    • 静态成员函数没有 this 指针,只能访问静态成员(包括静态成员变量和静态成员函数)。
    • 普通成员函数有 this 指针,可以访问类中的任意成员;而静态成员函数没有 this 指针。
    展开全文
  • C++——内联,友元

    2018-08-06 11:00:16
    inline时一种以时间换空间的做法,省去调用函数的开销,所以代码很长或内部有循环,递归的函数不适宜使用内联 inline对编译器只是一个建议,编译器会自动优化。如果定义为inline的函数体内有循环/递归等等,编译器...
  • C++关于类一些笔记

    2015-05-09 15:50:27
    1. 友元函数不能之间访问对象数据成员,也不能通过this指针访问,只能用函数参数传递进来(访问规则和成员函数一致) 2. 派生类继承基类的成员,访问权限为继承规则和声明时权限最低的那个 3. 函数的参数或返回值...
  • 4.10 函数的递归调用 4.11 局部变量和全局变量 4.12 变量的存储类别 4.13 变量属性小结 4.14 关于变量的声明和定义 4.15 内部函数和外部函数 4.16 预处理命令 第5章 数组 5.1 数组的概念 5.2 一维数组的...
  • 8.2 友元函数和自动类型转换 221 8.2.1 构造函数的自动类型转换 221 8.2.2 友元函数 222 8.2.3 友元类 225 8.3 引用和其他操作符重载 226 8.3.1 引用 226 8.3.2 重载“《”和“》” 228 8.3.3 赋值操作符 ...
  • 8.6 函数的递归调用 109 8.7 数组作为函数参数 110 8.8 局部变量和全局变量 112 8.8.1 局部变量 113 8.8.2 全局变量 119 8.9 变量的存储类别 120 78.9.1 动态存储方式与静态动态存储方式 120 8.9.2 auto变量 120 ...
  • 8.4 用作类成员与友元函数的运算符函数 8.5 重载流插入与流读取运算符 8.6 重载一元运算符 8.7 重载二元运算符 8.8 实例研究:Array类 8.9 类型之间的转换 8.10 实例研究:String类 8.11 重载十十与—— ...
  • c++ 程序设计

    2019-01-20 22:53:37
    4.10 函数的递归调用 4.11 局部变量和全局变量 4.11.1 局部变量 4.11.2 全局变量 4.12 变量的存储类别 4.12.1 动态存储方式与静态存储方式 4.12.2 自动变量 4.12.3 用static声明静态局部变量 4.12.4 用register声明...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类类型转换。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类类型转换。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类类型转换。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配...
  • 易学C++,C++入门

    2009-12-06 14:30:11
     12.3 函数的递归   12.3.1 什么是栈   12.3.2 函数的调用机制   12.3.3 小试牛刀——用递归模拟栈   12.3.4 *递归的精髓   12.4 方法指导   12.5 习题  第三篇 面向对象的程序设计  第13章...
  • C-Learn-Note-源码

    2021-03-31 13:39:12
    最近重温了C ++入门 复习了C ++加深一些理解 这里是一些学习c ++过程笔记 了解Note目录(括号中表示当前程序关联其他文件位于其他文件文件夹下): ...18.模板递归和普通递归的比较 19.双向循环链表 20.type_traits
  • 4.4.2 递归函数的作用 106 4.4.3 递归与循环的选择 108 4.4.4 递归函数实例 109 4.5 函数名重载 111 4.6 带缺省值的形式参数 114 4.7 内联函数 116 4.8 条件编译 119 4.8.1 基于多环境的程序编制 119 4.8.2 程序调试...
  • 03_结构体数据类型的嵌套定义和函数的嵌套调用是两个不同的概念 04_静态链表及局限性 05_链表的分类和链表的辅助指针变量 06_链表api函数搭建 07_链表的创建和打印 08_链表的插入操作和辅助指针变量分析_传智扫地僧 ...
  • C++ Primer Plus 中文版 第4版 清晰版

    千次下载 热门讨论 2009-12-06 14:45:21
    7.1 复习有关函数的基本知识 167 7.1.1 定义函数 167 7.1.2 函数原型和函数调用 169 7.2 函数参数和按值传递 171 7.2.1 多个参数 172 7.2.2 另外一个接受两个参数的函数 174 7.3 函数和数组 175 7.3.1...
  • 7.5.2 类的友元函数 7.5.3 默认复制构造函数 7.6 this指针 7.7 类const对象 7.7.1 类const成员函数 7.7.2 类外部成员函数定义 7.8 类对象数组 7.9 类静态成员 7.9.1 类静态数据成员 7.9.2 类静态函数...
  • 7.5.2 类的友元函数 7.5.3 默认复制构造函数 7.6 this指针 7.7 类const对象 7.7.1 类const成员函数 7.7.2 类外部成员函数定义 7.8 类对象数组 7.9 类静态成员 7.9.1 类静态数据成员 7.9.2 类静态函数...
  • 7.5.2 类的友元函数 7.5.3 默认复制构造函数 7.6 this指针 7.7 类const对象 7.7.1 类const成员函数 7.7.2 类外部成员函数定义 7.8 类对象数组 7.9 类静态成员 7.9.1 类静态数据成员 7.9.2 类静态函数...
  • AICJava课程7-12章

    2007-07-29 20:55:11
     理解构造函数的作用(分配对象空间),理解和定义重载的构造函数。  明白this引用的两种用法。  弄清对象类型与基本类型的区别。  掌握private, public访问控制符。  理解和使用关键字...
  • C语言程序设计(高清PDF)

    千次下载 热门讨论 2010-12-27 16:54:09
    4.3 函数的调用与参数 63 4.3.1 形式参数与实际参数 64 4.3.2 赋值调用与引用调用 64 4.4 递归 64 4.5 实现问题 66 4.5.1 参数和通用函数 66 4.5.2 效率 66 4.6 函数库和文件 67 4.6.1 程序文件的大小 67 4.6.2 分类...
  • 7.5.2 类的友元函数 321 7.5.3 默认复制构造函数 323 7.6 this指针 325 7.7 类const对象 327 7.7.1 类const成员函数 327 7.7.2 类外部成员函数定义 328 7.8 类对象数组 329 7.9 类静态成员 331 7.9.1 类...
  • 6.4 带有构造函数和析构函数的stash 152 6.5 带有构造函数和析构函数的stack 154 6.6 集合初始化 156 6.7 默认构造函数 158 6.8 小结 159 6.9 练习 159 第7章 函数重载与默认参数 161 7.1 名字修饰 162 ...
  • 21天学通C++ (中文第五版)

    热门讨论 2010-06-23 16:57:03
    12.3 构造函数和析构函数的继承性 12.4 覆盖基类函数 12.4.1 隐藏基类方法 12.4.2 调用基类方法 12.5 虚方法 12.5.1 虚函数的工作原理 12.5.2 通过基类指针访问派生类的方法 12.5.3 切除 12.5.4 创建虚析构...
  • 面向对象软件工程是面向对象方法在软件工程领域全面应用,它包括面向对象分析(OOA)、面向对象设计(OOD)、面向对象编程(OOP)、面向对象测试(OOT)和面向对象软件维护(OOSM)等主要内容。...
  • 302 理解友元函数 303 理解虚函数 304 理解抽象类 305 理解嵌套数据类型 306 理解静态成员 307 理解静态函数 308 理解静态数据成员 309 使用静态成员 310 理解作用域分辨 311 理解回调函数 312 理解操作符重载 313 ...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

友元函数的递归调用