C++期中考试（判断）

一、判断题

R1-1

using namespace std; 这条语句的作用是将命名空间std内的所有标识符暴露在当前作用域内。（T）

R1-2

主程序调用内联函数（inline）时，不发生控制转移，无需保存和恢复环境变量等，因此，节省了系统开销。内联函数的声明以及最终的生效，是由程序员决定的。（F）

一个内联函数的例子：

#include <iostream>
using namespace std;

//内联函数，交换两个数的值
inline void swap(int *a, int *b){
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int main(){
    int m, n;
    cin>>m>>n;
    cout<<m<<", "<<n<<endl;
    swap(&m, &n);
    cout<<m<<", "<<n<<endl;
    return 0;
}
//何时采用内联函数？
//当函数比较复杂时，函数调用的时空开销可以忽略，大部分的 CPU 时间都会花费在执行函数体代码上，所以我们一般是将非常短小的函数声明为内联函数。
//对函数作 inline 声明只是程序员对编译器提出的一个建议，而不是强制性的，并非一经指定为 inline 编译器就必须这样做。编译器有自己的判断能力，它会根据具体情况决定是否这样做。所以这题错误

R1-3

函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。（T）

一个重载函数的例子：

#include <iostream>
using namespace std;

//交换 int 变量的值
void Swap(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

//交换 float 变量的值
void Swap(float *a, float *b){
    float temp = *a;
    *a = *b;
    *b = temp;
}

//交换 char 变量的值
void Swap(char *a, char *b){
    char temp = *a;
    *a = *b;
    *b = temp;
}

//交换 bool 变量的值
void Swap(bool *a, bool *b){
    char temp = *a;
    *a = *b;
    *b = temp;
}

int main(){
    //交换 int 变量的值
    int n1 = 100, n2 = 200;
    Swap(&n1, &n2);
    cout<<n1<<", "<<n2<<endl;
   
    //交换 float 变量的值
    float f1 = 12.5, f2 = 56.93;
    Swap(&f1, &f2);
    cout<<f1<<", "<<f2<<endl;
   
    //交换 char 变量的值
    char c1 = 'A', c2 = 'B';
    Swap(&c1, &c2);
    cout<<c1<<", "<<c2<<endl;
   
    //交换 bool 变量的值
    bool b1 = false, b2 = true;
    Swap(&b1, &b2);
    cout<<b1<<", "<<b2<<endl;

    return 0;
}

重载就是在一个作用范围内（同一个类、同一个命名空间等）有多个名称相同但参数不同的函数。重载的结果是让一个函数名拥有了多种用途，使得命名更加方便（在中大型项目中，给变量、函数、类起名字是一件让人苦恼的问题），调用更加灵活。

参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。

R1-4

如果公有派生，则可以用派生类对象给基类对象赋值。（T）

继承和派生、基类（父类）和派生类（子类）的概念。

继承（inheritance）可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类 B 继承于类 A，那么 B 就拥有 A 的成员变量和成员函数。派生和继承是同一个概念，之所以名字不同是因为站的角度不同，继承是儿子接收父亲的产业，派生是父亲把产业传承给儿子。

被继承的类称为是父类或者基类，继承的类称为是子类或派生类。子类和父类通常放在一起称呼，基类和派生类通常放在一起称呼。

public、protected、private 三个关键字除了可以修饰类的成员，还可以指定继承方式。使用public关键字时就称为是公有派生，下面是一个公有派生的例子：

#include<iostream>
using namespace std;

//基类 Pelple
class People{
public:
    void setname(char *name);
    void setage(int age);
    char *getname();
    int getage();
private:
    char *m_name;
    int m_age;
};
void People::setname(char *name){ m_name = name; }
void People::setage(int age){ m_age = age; }
char* People::getname(){ return m_name; }
int People::getage(){ return m_age;}

//派生类 Student
class Student: public People{
public:
    void setscore(float score);
    float getscore();
private:
    float m_score;
};
void Student::setscore(float score){ m_score = score; }
float Student::getscore(){ return m_score; }

int main(){
    Student stu;
    stu.setname("小明");
    stu.setage(16);
    stu.setscore(95.5f);
    cout<<stu.getname()<<"的年龄是 "<<stu.getage()<<"，成绩是 "<<stu.getscore()<<endl;

    return 0;
}

在公有派生的情况下，有以下三条赋值兼容规则。

1.派生类的对象可以赋值给基类对象。

2.派生类对象可以用来初始化基类引用。

3.派生类对象的地址可以赋值给基类指针，亦即派生类的指针可以赋值给派生类对象。

下面这个例子充分说明了这三条原则：

class A {
};
class B : public A  //公有派生
{
};
int main()
{
    A a;
    B b;
    a = b;  //派生类对象赋值给基类对象
    A& r = b;  //派生类对象初始化基类引用
    A* pa = &b;  //派生类对象地址赋值给基类指针
    B* pb = &b;
    pa = pb;  //派生类指针赋值给基类指针
    return 0;
}

R1-5

this 指针是一个系统预定义的特殊指针,指向当前正在操作的对象。（T）

参考链接：http://c.biancheng.net/view/2226.htmlhttp://c.biancheng.net/view/2226.html

R1-6

C++程序中，类的构造函数名与类名相同。（T）

C++构造函数详解