假如有以下类A： classA{ public： int func（int a){return a*a;） }; 以下程序片段中不正确的是（ ） A. A a;a.func(5); B. A*p=new A; p->func(5); C. A a; A& r=a;r.func(5); D. A a,b; if(a!=b) a.func(5);

程序片段中不正确的是 D 选项，`if(a!=b) a.func(5);`。因为在类 A 中并没有定义 `!=` 运算符，所以不能直接比较两个类 A 的对象。正确的比较方式是通过定义 `==` 运算符或者其他相关的成员函数进行比较。其他选项都是正确的方式调用类 A 的成员函数：

- A 选项：通过类 A 的对象直接调用成员函数。
- B 选项：通过类 A 的指针调用成员函数。
- C 选项：通过类 A 的引用调用成员函数。

相关问题

#include<iostream> using namespace std; class ClassA{ public: //**********found********** virtual void print( ) // 说明print函数为虚函数 { cout<<"ClassA"<<endl; } }; class ClassB:public ClassA{ public: void print( ) { cout<<"ClassB"<<endl; } }; //**********found********** void func(ClassA &t) { t.print(); } int main() { ClassA testa; ClassB testb; func(testa); func(testb); //**********found********** ClassA* p; // 定义指针p p=&testa; p->print(); //**********found********** p=&testb; p->print(); system("pause"); return 0; }请解释这个代码

这段代码主要演示了虚函数的作用和多态的实现。

在 ClassA 类中声明了一个虚函数 print()，表示该函数可以被子类重写。在 ClassB 类中重写了 print() 函数，输出 "ClassB"。在 func() 函数中，参数为一个 ClassA 类的引用，通过该引用调用 print() 函数，由于 ClassB 是 ClassA 的子类，所以传递 ClassB 的对象时会调用 ClassB 中的 print() 函数，输出 "ClassB"。

在 main() 函数中，先创建了 ClassA 和 ClassB 的对象 testa 和 testb，分别调用 func() 函数，输出 "ClassA" 和 "ClassB"。然后定义了一个指向 ClassA 类对象的指针 p，并分别将其指向 testa 和 testb，调用 p->print() 函数，由于 p 指向的对象不同，因此输出结果也不同，分别输出 "ClassA" 和 "ClassB"。

这就是多态的实现，同一个函数在不同的对象上有不同的表现形式。

已知如下一个类:classA｛int a1，a2；A（int i，int j）｛a1=i；a2=j；｝｝要求编写一个方法swap（）用来交换A类的两个成员变量的值

可以在 `classA` 中添加一个 `swap` 方法来实现交换成员变量的值，具体代码如下：

class classA {
public:
    int a1, a2;
    classA(int i, int j) {
        a1 = i;
        a2 = j;
    }
    void swap() {
        int tmp = a1;
        a1 = a2;
        a2 = tmp;
    }
};

这样，当需要交换 `classA` 的两个成员变量时，只需要调用 `swap` 方法即可。例如：

classA obj(1, 2);
cout << obj.a1 << " " << obj.a2 << endl; // 输出 1 2
obj.swap();
cout << obj.a1 << " " << obj.a2 << endl; // 输出 2 1