下面程序中对一维坐标点类Point进行运算符重载 include using namespace std;下面程序中对一维坐标点类Point进行运算符重载 #include ＜iostream＞ using namespace std; class Point { public: Point(int val) {x=val;} Point & operator++() {x++; return *this; } Point operator++(int) {Point ld = *this; ++(*t
题目
下面程序中对一维坐标点类Point进行运算符重载 #include ＜iostream＞ using namespace std; class Point { public: Point(int val) {x=val;} Point & operator++() {x++; return *this; } Point operator++(int) {Point ld = *this; ++(*this); return old;} int GetX() const {return x;} private: int x; }; int main() { Point a(10); cout ＜＜ (++a).GetX(); cout ＜＜ a++.GetX(); return 0; }编译和运行情况是
A．运行时输出1011
B．运行时输出1111
C．运行时输出1112
D．编译有错
相似考题
更多“下面程序中对一维坐标点类Point进行运算符重载 include using namespace std; 下面程序中对一维坐标点类Point进行运算符重载 #include ＜iostream＞ using namespace std; class Point { public: Point(int val) {x=val;} Point operator++() {x++;”相关问题
-
第1题：
有如下程序:includeusing namespace std;class Point{public: static int number; 有如下程序：#include＜iostream＞using namespace std；class Point{public： static int number；public： Point(){number++；} ～Point(){number--；}}；int Point::number=0；void main(){ Point*ptr； Point A，B； { Point*ptr_point=new Point[3]； ptr=pb_point； } Point C cout＜＜Point::number＜＜endl； delete[]ptr； }运行时输出的结果是
A．3
B．4
C．6
D．7
正确答案：C
解析：本题考查的知识点是：静态成员，对象的构造，对象的生存周期。静态成员的特性是不管这个类创建了多少个对象，它的静态成员都只有一个拷贝(副本)，这个副本被所有属于这个类的对象共享。本题的Point类中就定义了一个静态成员变量 number。其初始值为0，每次构造则自动增1，析构则自动减1，所以number是Point类对象的计数值。在主函数中，第1行定义了1个Point类型指针ptr，这并不会构造 Point类对象，因此number值为0；第2行定义了2个Point对象，所以此时number值为2；第3～6行是一个语句块，其中通过new运算符又定义了1个包含3个Point对象元素的数组，由于是动态创建的，所以其生命周期只能通过delete运算符来结束，否则会一直占据内存直到程序结束，所以现在number的值为5：第7行定义了1个 Point对象C，number的值变为6；第8行输出number的内容，所以最后输出的结果是6。故本题应该选择C。 -
第2题：
下面程序的输出结果是【】。 incldeinclude 下面程序的输出结果是【 】。
inclde＜iostreamn＞
include＜math＞
using namespace std；
class point
{
private：
double x；
double y；
public：
point(double a，double b)
{
x=a；
y=b；
}
friend double distance(point a,point b)；
}；
double distance(point a，point b)
{
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))；
}
int main()
{
point p1(1，2)；
point p2(5，2)；
cout＜＜distalice(p1，p2)＜＜endl；
return 0；
}
正确答案：4
4 -
第3题：
下列程序的输出结果为: bjectid=O biectid=1 请将程序补充完整。 includeusing namesp 下列程序的输出结果为：
bjectid=O
biectid=1
请将程序补充完整。
include＜iostream＞
using namespace std;
class Point
{
public:
Point(int xx=0,int yy=0){X=xx;Y=yy;countP++;}
～Point(){countP--;}
int GetX(){return X;}
int GetY(){return Y;}
static void GetC(){cout＜＜"Object id="＜＜countP＜＜endl;}
private:
int X,Y;
static int countP;
};
______//静态数据成员的初始化
int main()
{
Point::GetC();
Point A(4,5);
A.GetC();
return 0;
}
正确答案：int tPoint::countP=0；
int tPoint::countP=0； 解析：此题考查的是类中静态数据成员的初始化，静态数据成员初始化的一般格式：数据类型类名::静态数据成员名=初始值，且初始化时前面不加关键字static。分析题目，首先调用构造函数，然后输出countP的值，所以couatP的初始值应设置为0，即横线处填入int Point::countP=0;。 -
第4题：
下面程序的输出结果是()。includeinclude using namespace std;class point{p 下面程序的输出结果是( )。 #include＜iostream＞ #include＜math.h＞ using namespace std; class point { private: double x; double y; public: point(double a,double b) { x=a; y=b; } friend double distances(point a,point b); }; double distances(point a,point b) { return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); } int main() { point p1(1,2); point p2(5,2); cout＜＜distances(p1,p2)＜＜end1; return 0; }
A．2
B．4
C．8
D．16
正确答案：B
解析：分析题目，此题最终要实现的结果是sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))，其中的a.x和a.y分别指p1(1，2)中的1和2。这样容易得到结果是(1-5)*(1-5)+(2-2)*(2-2)=16，再开方得到结果为4。 -
第5题：
有如下程序:includeusing namespace std;class point{int x, y;public:point( int v 有如下程序：#include ＜iostream＞using namespace std;class point{ int x, y;public: point( int vx, int vy ) { X=vx; y=vy; } point() { x=0; y=0; } point operator+ ( point p1 ) { point p; int px = x + p1.x; int py = y+ p1.y; return point( px, py ); } point operator-( point p1 { point p; int px = x - p1.x; int py = y - p1.y; return point( px, py ); } void print() { cout＜＜x＜＜","＜＜y＜＜end1; }};int main(){ point p1( 10, 10 ), p2( 20, 20 ); p1 = p1 + p2; p1.print(); return ();}执行后的输出结果是( )。
A．10, 10
B．20, 20
C．10, 20
D．30, 30
正确答案：D
-
第6题：
有以下程序:includeusing namespace std;definePl 3.14Class Point{private:int x,y 有以下程序： #include＜iostream＞ using namespace std； #definePl 3.14 Class Point {private： int x，y； public： Point(int a，intB) {X＝a； y：b；} int getx() ＜return x；} int gety() {return y；}}； class Circle：public Point {pri
A．314
B．157
C．78.5
D．153.86
正确答案：A
解析： 本程序设计了一个点类Point，包含了横，纵两个坐标数据x和y，由它派生出了圃类Circle，并加入了新的数据成员，即一个半径r和一个求圆面积的函数成员area。在主函数main中，首先定义了一个圃Circle类的对象c1，并通过它的构造函数初始化其数据成员。由此可知，其半径r的值为10，所以其面积为PI*10*10=314，即对象c1的函数成员area的返回值为314。 -
第7题：
有以下程序:includeinclude 有以下程序： #include＜iostream＞ #include＜math＞ using namespace std； class point { private： double x； double y； public： point(double a,double B) { x=a； y=b； } friend double distance (point a,point B) ；
A．1
B．5
C．4
D．6
正确答案：C
解析：本题考核友元函数的应用。分析程序：类point中定义了两个私有成员x和y，以及一个友元函数distance。从而，函数distance可以访问类point中的任何成员。在函数distance中，返回值为sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))。由此可知，函数distance的功能是计算a、b两点之间的距离。在主函数main中，先定义两点：p1(1，2)和p2(5，2)。然后调用函数distance计算两点之间的距离为4，所以程序最后输出为4。 -
第8题：
有如下程序:includeusing namespace std;class point{intx,y;public:point( int vx, 有如下程序：#include ＜iostream＞using namespace std;class point{ int x, y;public: point( int vx, int vy ) { x = vx; y = vy; } point ( ) x = 0; y= 0; } point operator+( point p1 ) { point p; int px = x+ p1.x; int py = y + p1.y; return point( px, py ); point operator-( point p1 ) { point p; int px = x -p1.x; int py = y - p1.y; return point ( px, py ); } void print() { cout＜＜x＜＜" , "＜＜y＜＜end1; }};int main (){ point p1(10, 10 ), p2( 20, 20 ); p1 = p1 - p2; p1.print (); return 0;} 执行后的输出结果是
A．10，10
B．20，20
C．10，20
D．30，30
正确答案：D
解析：本题主要考查C++中运算符重载的机制与实现。运算符重载函数一般分为成员函数形式和友元函数形式，这两种形式都可以访问类中的私有成员。本题中的运算符重载形式为成员函数形式。程序在类point中声明了私有数据成员int x和 int y，并定义了两种形式的构造函数以完成对对象的初始化；之后，程序对运算符“+”进行了重载，另其输入参数为类point的对象，输出为操作符“+”右侧该对象的私有数据成员x和y与操作符“+”左侧同类型对象的私有数据成员x和y的加和：print()函数则输出对象中数据成员的值。程序main()函数中，实例化了类point的两个对，象p1和p2，并完成对对象的初始化．在语句“p1= p1+p2；”中，由于操作符“+”左右两端的操作数为point类的对象，复合类point定义中的操作符“+”的重载函数，因此程序将调用重载后的操作符函数，并返回两point对象数据成员的加和值，覆盖对象p1的数据成员．因此print()函数输出对象p1的数据成员值己应该为：x=10+20=30，y=10+20=30 -
第9题：
有如下程序: includeusing namespace std; class point {int x,y; public:point( i 有如下程序： #include ＜iostream＞ using namespace std; class point { int x, y; public: point( int vx, int vy ) { x = vx; y = vy; } point ( ) { x = 0; y = 0; } point operator+( point pl ) { point p; int px = x + p1.x; int py = y + p1.y; return point( px, py ); } point operator-( point p1 ) { point p; int px = x - p1.x; int py = y - p1.y; return point( px, py ); } void print() { cout＜＜x＜＜", "＜＜y＜＜end1; } }; int main () { point pl ( 10, 10 ), p2 ( 20, 20 ); p1 = p1 + p2; p1.print (); return 0; } 执行后的输出结果是( )。
A．10,10
B．20,20
C．10,20
D．30,30
正确答案：D
解析：本题主要考察C++中运算符重载的机制与实现。运算符重载函数一般分为成员函数形式和友元函数形式，这两种形式都可以访问类中的私有成员。本题中的运算符重载形式为成员函数形式。程序在类point中声明了私有数据成员intx和inty，并定义了两种形式的构造函数以完成对对象的初始化：之后，程序对运算符“+”进行了重载，令其输入参数为类point的对象，输出为操作符“+”右侧该对象的私有数据成员x和y与操作符“+”左侧同类型对象的私有数据成员x和y的两数之和；print()函数则输出对象中数据成员的值。主函数中，实例化了类point的两个对象p1和p2，并完成对对象的初始化。在语句“p1=p1+p2；”中，由于操作符“+”左右两端的操作数为point类的对象，复合类point定义中的操作符“+”的重载函数，因此程序将调用重载后的操作符函数，并返回两point对象数据成员的加和值，覆盖对象p1的数据成员。因此print()函数输出对象p1的数据成员值应该为：x=10+20=30，y=10+20=30。 -
第10题：
有以下程序:includeusing namespace std;define PI 3.14class Point{ private:int 有以下程序： #include ＜iostream＞ using namespace std; #define PI 3.14 class Point { private: int x,y; public: Point(int a,int b) { x=a; y=b; } int getx() { return x; }
A．314
B．157
C．78.5
D．153.86
正确答案：A
解析：本题考核派生类的定义和应用。本程序设计了一个点类Point，包含了横、纵两个坐标数据x和y，由它派生出了圆类Circle，并加入了新的数据成员，即一个半径r和一个求圆面积的函数成员area。在主函数main中，首先定义了一个圆Circle类的对象c1，并通过它的构造函数初始化其数据成员。由此可知，其半径r的值为10，所以其面积为PI*10'10=314，即对象c1的函数成员area的返回值为314。 -
第11题：
若有以下程序:includeusing namespace std;class point{private: int x, y;public: 若有以下程序： #include ＜iostream＞ using namespace std; class point { private: int x, y; public: point ( ) { x=0; y=0; } void setpoint(int x1,int y1) { x=x1; y=y1;
A．12,12
B．5,5
C．12,5
D．5,12
正确答案：D
解析：本题考核对象指针的定义与使用。分析程序：程序首先定义一个类point。类point中有两个私有成员，整型变量x和y，还有两个公有成员函数setpoint(intx1,inty1)和dispoint()。函数setpoint()用来设置私有成员x和y的值，而函数dispoint()用来显示私有成员x和y的值。主函数中，首先定义了类point的指针对象p，并申请了内存空间，然后调用对象p中公有成员setpoint给对象p中的私有成员x和y赋值，然后调用成员函数dispoint显示x和y的值。由此可知，最后输出的值应该是5,12。 -
第12题：
在下面横线上填上适当的语句,完成程序。includeusing namespace std; class Base { in 在下面横线上填上适当的语句，完成程序。
include＜iostream＞
using namespace std；
class Base
{
int x；
public：
Base(int i){x＝i；}
～Base(){}
)；
class Derived：public Base
{
public：
______//完成类Derive构造函数的定义
};
iht main()
{
Derived obj
正确答案：Derived(int i；Base(i){}。
Derived(int i；Base(i){}。 解析： 程序中，类Derived是基类Base的公有派生。在类Derived的构造函数应该包括调用基类构造函数使基类的数据成员得以初始化， -
第13题：
程序的输出结果是【 】。 includeusing namespace std; class A{ int x; public: A(int 程序的输出结果是【 】。
include ＜iostream＞
using namespace std；
class A{
int x；
public：
A(int x=1)：x(x){cout＜＜x；}
}；
void main(){
A a，b(2)，c(3)；
}
正确答案：123
123 解析：a对象使用和默认的构造函数，b对象使用2来初始化对象c对象使用3来初始化对象，输出相应的值后，结果变为123。 -
第14题：
有如下程序: includeusing namespace std; class Point{ int x, y; public: Point(i 有如下程序：
#include＜iostream＞
using namespace std;
class Point{
int x, y;
public:
Point(int x1=0, int y1=0):x(x1), y(y1){}
int get(){return x+y;)
};
class Circle{
Point center;
int radius;
public:
Circle(int CX, int cy, int r):center(cx, cy), radius(r){}
int get(){return center. get()+radius;}
}；
int main(){
circle c(3, 4, 5);
cout＜＜c. get()＜＜end1;
return ():
}
运行时的输出结果是( )。
A) 5
B) 7
C) 9
D) 12
A．
B．
C．
D．
正确答案：D
-
第15题：
有以下程序: includeusing namespace std; class Point' { public: void SetPoint( 有以下程序： #include ＜iostream＞ using namespace std; class Point' { public: void SetPoint(int x,int y); void Move(int xOff,int yOff); int GetX() { return X; } int GetY() { return Y; } private: int X,Y; }; void Point::SetPoint(int x, int y) { X=x; Y=y; } void Point: :Move(int xOff, int yOff) X+=xOff; Y+=yOff; } int main () { Point p1; p1.SetPoint(1,2); p1.Move (5, 6); cout＜＜"Point1 is ("＜＜p1.GetX()＜＜','＜＜p1.GetY()＜＜")"＜＜end1; return 0; } 执行后的输出结果是( )。
A．Point1 is (6,8)
B．Point1 is (1,2)
C．Point1 is (5,6)
D．Point1 is (4,4)
正确答案：A
解析：本题考核对象的定义与使用。程序中定义了一个类Point，在主函数中定义了一个Point类的对象p1，然后通过对象p1调用其成员函数SetPoint()和Move()实现移位的操作。 -
第16题：
下面程序的输出结果是【】。 includeusing namespace std; class A {int a,b; public:A 下面程序的输出结果是【 】。
include ＜iostream＞
using namespace std;
class A
{
int a, b;
public:
A()
{
a = b = 0;
}
A(int aa, int bb ) : a(aA) , b(bB)
{
cout ＜＜"a="＜＜a＜＜","＜＜"b="＜＜b＜＜",";
}
～A()
{
cout＜＜"D";
};
int main ( )
{
A x, y(2, 3);
return 0;
}
正确答案：a=2b=3DD
a=2,b=3DD 解析：本题主要考核构造函数与析构函数的应用。主函数中定义 A类对象x时无输出，定义对象y时调用构造函数输出a=2，b=3。在主函数结束前，对象x,y都调用各自的析构函数输出DD。所以最后答案为a=2，b=3DD。 -
第17题：
下面程序执行的结果是【 】 includeusing namespace std; class A{ public: static in 下面程序执行的结果是【 】
include＜iostream＞
using namespace std；
class A{
public：
static int x；
A(inty){cout＜＜x+y；}
}；
int A：：x=2；
void main(){
A a(5)；
}
正确答案：7
7 解析：程序的静态变量初始化为2，而构造函数招待过程中y变量为初始化为5，故程序执行的结果为7。 -
第18题：
有如下程序： #inClude<iostream> using namespaCe std； Class Point{ publiC： statiC int number； publiC： Point（ ）t．number++；} ~Point（ ）{number--；} }； ， int P0int：：number=0； int main（ ）{ Point *ptr： Point A，B； Point*ptr_point=new Point[3]； ptr=ptr_point；’ } Point C； Cout<<Point：：：number<<endl； delete[]ptr； return 0； } 执行这个程序的输出结果是（ ）。
A.3
B.4
C.6
D.7
正确答案：C
本题考查默认构造函数．题目中定义．个对象A、B以及对象数组Point[3]，又定义了对象C，共执行6次构造函数，number变为了6，所以本题答案为C。 -
第19题：
有以下程序:includeinclude 有以下程序：#include ＜iostream＞#include ＜math＞using namespace std;class point{private: double x; double y;public: point(double a, double b { x=a; y=b; friend double distance (point a, point b ; };double distance(point a, point b return sqrt((a. x-b. x )*(a. x -b. x )+ (a. x -b. x)*(a. x-b. x));}int main (){ point p1 (1,2); point p2(5,2); cout＜＜distance (p1, p2)＜＜end1; return 0;} 程序运行后的输出结果是
A．1
B．5
C．4
D．6
正确答案：C
解析：本题考核友元函数的应用。分析程序：类point中定义了两个私有成员x和y，以及一个友元函数distance。从而，函数distance可以访问类point中的任何成员。在函数distance中，返回值为sqrt ((a. x- b. x)*(a. x-b. x)+(a. y-b. y)*(a. y-b. y))。由此可知，函数distance的功能是计算a、b两点之间的距离。在主函数main中，先定义两点：p1(1,2)和p2(5，2)。然后调用函数distance计算两点之间的距离为4，所以程序最后输出为4。 -
第20题：
有以下程序:includeinclude 有以下程序： #include ＜iostream＞ #include ＜math＞ using namespace std; class point { private: double x; double y; public: point(double a,double b) { x=a; y=b; } friend double distance(point a,point b) ; }; double distance(point a,point b) { return sqrt ((a.x-b.x)* (a.x-b.x)+(a.y-b.y)*(a.y-b.y)); } int main ( ) { point pl(1,2); point p2 (5, 2); cout＜＜distance (pl,p2) ＜＜end1; return 0; } 程序运行后的输出结果是( )。
A．1
B．5
C．4
D．6
正确答案：C
解析：本题考核友元函数的应用。分析程序：①类point中定义了两个私有成员x和y，以及一个友元函数distance()。从而，函数distance可以访问类point中的任何成员。②在函数distance()中，返回值为sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))。由此可知，函数distance()的功能是计算a、b两点之间的距离。③在主函数中，先定义两点：p1(1，2)和p2(5，2)。然后调用函数distance()计算两点之间的距离为4，所以程序最后输出为4。 -
第21题：
有如下程序:includeusing namespace std;class point{int x,y;public:point(int vx,i 有如下程序： #include＜iostream＞ using namespace std； class point { int x，y； public： point(int vx，int vy) { x=vx； y=vy； } point() { x=0； y=0； } point operator+(point p1) { point p； int px=x+p1.x； int py=y+p1.y； return point(px，py)； } point operator-(point p1) { point p； int px=x-p1.x； int py=y-p1.y； return point(px，py)； } void print() { cout＜＜x＜＜","＜＜y＜＜end1； } }； int main() { point p1(10，10)，p2(20，20)； p1=p1+p2； p1.print()； retrun 0； } 执行后的输出结果是
A．10，10
B．20，20
C．10，20
D．30，30
正确答案：D
解析：本题主要考查C++中运算符重载的机制与实现。运算符重载函数一般分为成员函数形式和友元函数形式，这两种形式都可以访问类中的私有成员。本题中的运算符重载形式为成员函数形式。程序在类point中声明了私有数据成员intx和inty，并定义了两种形式的构造函数以完成对对象的初始化；之后，程序对运算符“+”进行了重载，另其输入参数为类point的对象，输出为操作符“+”右侧该对象的私有数据成员x和y与操作符“+”左侧同类型对象的私有数据成员x和y的加和：print()函数则输出对象中数据成员的值。程序main()函数中，实例化了类point的两个对象p1和p2，并完成对对象的初始化。在语句“p1=p1+p2；”中，由于操作符“+”左右两端的操作数为point类的对象，复合类point定义中的操作符“+”的重载函数，因此程序将调用重载后的操作符函数，并返回两point对象数据成员的加和值，覆盖对象p1的数据成员。因此print()函数输出对象p1的数据成员值应该为：x=10+20=30，y=10+20=30 -
第22题：
下面程序输出的结果是( )。 includeusing namespace std; class A{ 下面程序输出的结果是( )。 #include＜iostream＞ using namespace std； class A{ int X； public： A(int x)：x(++x){} ～A(){cout＜＜x；} }； class B：public A{ int y； public： B(int y)：A(y)，y(y){} ～B(){cout＜＜y；}； }； void main(){ B b(3)； }
A．34
B．43
C．33
D．44
正确答案：A
解析：对象创建的次序为：先基类，后派生类；析构时，先派生类，后基类。 -
第23题：
若有以下程序:includeusing namespace std;define PI 3.14class Point {private: i 若有以下程序: #include ＜iostream＞ using namespace std; #define PI 3.14 class Point { private: int x,y; public: Point(int a,int B) { x=a; y=b; } int getx() { return x; } int gety() { reurn y; } }; class Circle: public Point { private: int r; public: Circle(int a,int b.int C) :Point(a,B) r=c; int getr() { return r; } double area() { return PI*r*r; } }; int main() { Circle cl(5,7,10); cout＜＜c 1 .area()＜＜end1; return 0; } 程序执行后的输出结果是
A．314
B．157
C．78.5
D．153.86
正确答案：A
解析：本题考核派生类的定义和应用。本程序设计了一个点类Point，包含了横、纵两个坐标数据x和y，由它派生出了圆类Circle，并加入了新的数据成员，即一个半径数据r和一个求圆面积的函数成员area。在主函数main中，首先定义了一个圆Circle类的对象c1，并通过它的构造函数初始化其数据成员。由此可知，其半径r的值为10，所以其面积为PI*10*10=314，即对象c1的函数成员area的返回值为314。