c和c++做题小结

1、多继承的虚基类不能够实例化。

这句话是错误的，当不调用子类时，虚基类的函数当然就不会virtual的影响，而是照常可以实例化使用。

2、在类的非静态函数中this指针指向调用该函数的对象。

        这句话是正确的，注意非静态函数，因为多个对象的静态数据和函数都指向了同一块内存空间，不会随着新定义的对象而发生变化，所以this指针也就失去了应有的作用。

3、关于运算符重载：

（1）运算符重载定义：

C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。

运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下：

<返回类型说明符> operator <运算符符号>(<参数表>)
{
     <函数体>
}

举例说明：

例1：“+”重载

#include<iostream>

using namespace std;

class add {
public:
    int m_A, m_B;//为了方便看操作效果，一般设为private属性
    add() {}  //方便定义重载函数，需要自己写默认构造函数
    add(int a, int b) :m_A(a), m_B(b) {}
    add operator+(add &p) {
        add tmp;
        tmp.m_A = this->m_A + p.m_A;
        tmp.m_B = this->m_B + p.m_B;
        return tmp;
    }
};

/*add operator+(add &p1, add &p2) {
    add tmp;
    tmp.m_A = p1.m_A + p2.m_A;
    tmp.m_B = p1.m_B + p2.m_B;
    return tmp;
}*/   //代码段2

int main() {
    add p1(1,2);
    add p2(3,4);
    add p3 = p1 + p2;
    cout << p3.m_A << "   "<<p3.m_B << endl;
    system("pause");
    return 0;
}

在上面的程序中，使用代码段二可以起到同样的效果，类外实现。

 例2：“<<”重载

#include <iostream>

using namespace std;

class person {
    friend ostream& operator<<(ostream &cout, person &p); //外部函数调用私有的属性，可以采用friend的方法
public:
    person() {};
    person(int a, int b) :m_A(a), m_B(b) {}
private:
    int m_A, m_B;
};

ostream& operator<<(ostream &cout,person &p) {  //cout属于ostream这个类
    cout << p.m_A <<“   ”<< p.m_B;
    return cout;
}

int main() {
    person p(1,2);
    cout << p << endl;

    system("pause");
    return 0;
}

 例3：“++”前置后置重载

#include <iostream>

using namespace std;

class MyInteger {
    friend ostream& operator<<(ostream& cout, MyInteger & myInt);
private:
    int num;
public:
    MyInteger():num(0) {}
    MyInteger& operator++() {
        this->num++;
        return *this;
    }
    MyInteger operator++(int) {
        MyInteger tmp=*this;
        num++;
        return tmp;
    }
};

ostream& operator<<(ostream& cout, MyInteger & myInt)
{
    cout << myInt.num;
    return cout;
}


void test(){
    MyInteger p;
    cout << ++p << endl;
    MyInteger q=p++;
    cout << q << endl;
    cout << p << endl;
}

int main() {
    test();

    system("pause");
    return 0;
}

上面的代码输出的结果是1,1,2； 

（2）运算符重载时要遵循以下规则：

   1) 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，C++中的所有运算符都可以重载。
2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。

4、在用类来定义数组或者指针数组时，每一个数组只会调用一次构造函数和析构函数。