c++期末知识点快速复习，最全整理

Posted 2021-06-27 行码棋

c++期末知识点快速复习，最全整理（四）

• 四、某些关键词的用法
• • 1.const限定词
  • • 1.1.常对象
    • 1.2.常成员函数
    • 1.3.常数据成员
    • 1.4.对象常引用
  • 2.组合类
  • 3.友元
  • • 3.1 介绍:
    • 3.2 友元函数
    • 3.3 友元类
  • 4.this指针
  • 5.static变量
  • • 5.1.定义
    • 5.2.内存空间及初始化
    • 5.3.static成员变量
    • 5.4.static成员函数

四、某些关键词的用法

1.const限定词

1.1.常对象

将对象限定为const对象，即为常对象。

特性：
1.常对象在生存期它的所有数据成员都不可以改变
2.常对象在定义时就必须进行初始化，且不能被更新
3.常对象中的成员函数必须为常成员函数才能调用，否则就会出错

const修饰形式：
1.const 类名 对象名([参数列表])
2.类名 const 对象名([参数列表])

代码演示：假设已定义一个Time类，有年月日三个成员变量

Time const t1(2021,6,9);//定义t1常对象
//或const Time t1(2021,6,9);

注意：

如果一定要修改某个常对象的成员变量的值，可以将公式声明为mutable

mutable int count;

这样就可以用声明为const的常成员函数来修改它的值。

1.2.常成员函数

常对象只能调用常成员函数，这样保证常对象的数据成员不能修改。

特性:

1.函数实现时需要带上const关键字
2.常成员函数不能更新对象的数据成员，也不能调用非常成员函数。
3.常成员函数只能调用常成员函数，常成员函数也能被普通对象调用。

调用形式：

//在Time对象中对gethour方法定义为const成员函数
int Time::gethour() const
{

}

const关键字可以被用于参与对重载函数的区分。

const成员函数进行非const版本的重载。
编译器可以根据情况选择相应的重载函数。
如果对象是const，使用const版本的重载函数，如果是非const，使用非const版本的重载函数。

注意：
析构函数和构造函数不能进行const声明。
因为构造函数必须能够修改对象，析构函数需要对对象的内存进行回收。

1.3.常数据成员

使用const声明的数据成员为常数据成员。
对于常数据成员，任何函数都不能对它进行赋值，也不能通过构造函数赋值的方法进行赋值，只能通过初始化器进行赋值。

初始化器进行赋值：

class Time
{
private:
	const int hour;
	const int second;
	const int minute;
};
Time::Time(int h,int s,int m)
	:hour(h),second(s),minute(m) 
	{ }//注意花括号不能省略

1.4.对象常引用

对象的引用就是该对象的别名，对象名和引用名都指向相同的内存单元。
可以认为对象名和引用名的作用相同，属于同一个东西，就像一个人有两个名字一样。

使用场景：
希望通过引用名只能调用对象中的公有成员，而不能修改它们

声明形式：
const 类名 &引用名 = 对象名;

Time t1;
const Time &t2 = t1;//t1和t2指向同一段内存  

偷来一张图，嘿嘿，总结一下~

2.组合类

定义：在一个类的数据成员中出现一个或多个类的对象，那这个类就叫做组合类。

组合类构造函数定义的一般形式为：
类名::类名(形参表):内嵌对象1(形参表), 内嵌对象2(形参表),…
{
//类的初始化
}

其中，“内嵌对象1(形参表), 内嵌对象2(形参表),…”为初始化列表，用来完成对内嵌对象的初始化。
注意：
如果有多个内嵌对象，需要按它们在类中的声明顺序来调用他们对应的构造函数。最后在执行本类的构造函数。

#include<bits/stdc++.h>
using namespace std;

class Location
{
private:
    string loc;
public:
    Location(string s):loc(s){}
};
class Time
{
private:
    int hour;
    int minute;
    int second;
    Location l;
public:
    Time(int h,int m,int se,string s):l(s)
    {
        hour = h;
        minute = m;
        second = se;
    }
};
int main()
{
    Time t(12,12,12,"China");
    return 0;
}

3.友元

3.1 介绍:

在一个类中，使用关键字friend将别的模块（一般函数、其它类的成员函数或其它类）声明为本类的友元，这样类中本来隐藏的信息（私有和保护成员）就可以被友元访问。

可以说是friend为访问本类开了一个特殊的权限，本来内部的私有成员和保护成员不可以被外界访问，但是声明为friend的函数在外部可以访问到本类的私有成员。

友元提供了不同类或对象的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。

注意：
友元并不是类的成员。

3.2 友元函数

1、在类体内说明，在函数的类型说明符前加关键字friend；

2、在类体外定义，定义格式与普通函数相同；

3、友元函数是非成员函数，在调用上与普通函数相同；

4、友元函数可以直接访问该类中的私有成员。

下面以重载输入输出运算符为例来说明：

//实现对复数类的输入输出
#include<iostream>
using namespace std;
class CComplex
{
private:
    double real,imag;
public:
    CComplex(double r=0,double i=0):real(r),imag(i){}
    //内部声明
    friend istream& operator >> (istream& in,CComplex &c);
    friend ostream& operator << (ostream& out,CComplex c);
};
//外部实现
istream& operator >> (istream& in,CComplex &c)
{
    cout<<"请输入实部和虚部\\n";
    in >> c.real >> c.imag;
    return in;
}
ostream& operator << (ostream& out,CComplex c)
{
    if(c.imag<0)//虚部小于0
    {
        out<<c.real<<c.imag<<"i\\n";
        return out;
    }
    else if(c.imag==0)//虚部等于0
    {
        out<<c.real<<'\\n';
        return out;
    }
    else //虚部大于0
    {
        out<<c.real<<"+"<<c.imag<<"i\\n";
        return out;
    }
}
int main()
{
	CComplex cc;
    cin>>cc;
    cout<<cc;
	return 0;
}

3.3 友元类

当说明一个类为另一个类的友元时，友元类中的所有成员函数都是另一个类的友元函数。

也就是说友元类中的所有成员函数都可访问该类的私有变量。

声明形式：

friend class 类名;

注意：
1.友元关系不能传递。B类是A类的友元，C类是B类的友元，但C类并不是A类的友元。
2.友元关系是单向的。若B类是A类的友元，B类成员函数可以访问A类的私有变量，但是反过来A类成员函数并不能访问B类的私有变量。

4.this指针

this指针表示正在调用函数对象的地址。

什么意思呢？

当对象s 调用 s.set(2,15,1998) 时，成员函数除了接收传递的3个参数外，还接收到正在调用成员函数的对象s 的地址，这个地址放入隐含的形参this 指针中。

等同于执行 this=&s; 语句。

所以对成员函数内数据成员的访问都隐含地加上了this 指针。

因此， month=m;
等价于 this->month=m; 或 s.month=m;

this指针存的就是目前本对象的地址。

this指针的一个用处：
当成员函数中出现和成员变量同名的变量时，系统无法区分这些变量。使用this指针可以指向本类的成员变量，而另外一个变量就可以使用

Time(int hour,int minute,int second)
{
    this->hour = hour;//把参数hour的值赋给类中的hour私有变量
    this->minute = minute;
    this->second = second;
}

以下是完整的代码：

#include<iostream>
using namespace std;
class Time
{
private:
    int hour;
    int minute;
    int second;
public:
    Time(int hour,int minute,int second)
    {
        this->hour = hour;
        this->minute = minute;
        this->second = second;
    }
    void print()
    {
    //下面两种方式是一样的，都代表本类的成员变量
        // cout<<hour<<":"<<minute<<":"<<second<<'\\n';
        cout<<this->hour<<":"<<this->minute<<":"<<this->second<<'\\n';
    }
};
int main()
{
    Time t(12,12,12);
    t.print();
    return 0;
}

输出结果：

12:12:12

5.static变量

5.1.定义

引入static变量，表示这个变量为某个类的所有对象所共用，不单独属于某个对象，而是属于整个类。

静态数据成员的值对所有对象都是一样的。如果改变它的值，则各对象中该数据成员的值都同时改变。

下面一个图可以表示：

在类作用域内，可以通过类名和域运算符“∷”引用静态数据成员，而不论类对象是否存在。

5.2.内存空间及初始化

• 内存空间
  静态数据成员不随对象的建立而分配空间，也不随对象的撤销而释放。
  静态数据成员是在程序编译时被分配空间的，到程序结束时才释放空间。

• 初始化

  • 不能用构造函数初始化赋值；
  • 不能放在主函数中初始化；
  • 在程序定义该类的任何对象之前，对类中的static数据成员单独初始化；

初始化形式：
数据类型 类名::static数据成员名 = 初始化值；

注：

• 在初始化语句中不必加static。
• 如果未对静态数据成员赋初值，则编译系统会自动赋予初值0。

5.3.static成员变量

static成员变量声明为公有时，外部可以通过三种方式访问到：

• 通过对象名打点访问
• 通过类名和域运算符“∷”引用静态数据成员
• 通过静态成员函数进行访问。~静态成员函数下面会介绍。
  如果声明为私有的变量，只能通过内部的成员函数间接访问。

代码演示：

#include<iostream>
using namespace std;
class Time
{
private:
    int hour;
    int minute;
    int second;
public:
    static int year;//静态变量
    Time(int hour,int minute,int second)
    {
        this->hour = hour;
        this->minute = minute;
        this->second = second;
    }
    void print()
    {
        cout<<"year:"<<year<<"\\n";
        cout<<hour<<":"<<minute<<":"<<second<<'\\n';
    }
};
int Time::year = 2021;//静态变量初始化
int main()
{
	//访问静态公有的变量
    cout<<"year:"<<Time::year<<"\\n";
    Time t1(12,12,12),t2(10,10,10);
    t1.print();
    t2.print();
    return 0;
}

运行结果：

year:2021
year:2021
12:12:12
year:2021
10:10:10

可以看到上面的year都是2021，所有的Time对象公用一个静态数据year。

5.4.static成员函数

静态成员函数与静态成员变量几乎是一样的道理，表示对于同一个类的所有对象共享的成员函数，一般声明为公有。

注意：

• 静态成员函数没有this指针。静态成员函数不属于某个对象，为该类的所有对象共享，所以静态成员函数没有this指针
• 静态成员函数可以通过类名或对象直接访问
• 静态成员函数只能直接访问静态成员变量（函数），而不能直接访问普通成员变量（函数）

代码示例：

#include<iostream>
using namespace std;
class Time
{
private:
    int hour;
    int minute;
    int second;
public:
    static int year;
    Time(int hour,int minute,int second)
    {
        this->hour = hour;
        this->minute = minute;
        this->second = second;
    }
    static void print();
};
int Time::year = 2021;//静态变量初始化
void Time::print()
{
    cout<<"year:"<<year<<"\\n";
}
int main()
{
    cout<<"year:"<<Time::year<<"\\n";
    Time t1(12,12,12),t2(10,10,10);
    t1.print();
    t2.print();
    return 0;
}

运行结果：

year:2021
year:2021
year:2021

偷张图总结以下，嘿嘿嘿~