友元运算obj1＞obj2被C++编译器解释为：A．operator＞(obj1,obj2)B．＞(obj1,obj2)C．obj2.operator＞(obj1)D．obj1.operator＞(obj2)
题目
友元运算obj1＞obj2被C++编译器解释为：
A．operator＞(obj1,obj2)
B．＞(obj1,obj2)
C．obj2.operator＞(obj1)
D．obj1.operator＞(obj2)
相似考题
参考答案和解析
更多“友元运算obj1＞obj2被C++编译器解释为：”相关问题
-
第1题：
下面关于自定义类的运算符重载的说法中,正确的是()。A.类友元形式重载的运算符，重载函数的参数个数与运算符的实际操作数个数相同
B.类友元形式重载的运算符，重载函数中的this指针指向第一个运算数
C.类友元形式重载的运算符，重载函数中可以直接访问类中的私有成员
D.所有运算符都可以以类友元形式进行重载
正确答案：AC
-
第2题：
C++在重载运算将中，如用成员函数重载一元运算符参数表中需要______个参数，如用友元函数重载一元运算符参数表中需要______个参数。
正确答案：0 1
0 1 -
第3题：
下列运算符中全都可以被友元函数重载的是
A．＝、＋、－、\
B．[ ] 、＋、( ) 、new
C．－＞、＋、*、＞＞
D．＜ ＜、＞＞、＋、*
正确答案：D
解析：C＋＋中只能被成员函数重载的运算符是＝,[ ] ,( ) ,-＞,只能被友元函数重载的是 、＞＞ 。 -
第4题：
对于C++流运算符＞＞，说法正确的是 ______ 。
A．它可以重载为类的友元或成员函数
B．它是流类的一个输出运算符
C．C++内预定义了各种基本数据类型的输入操作
D．可以直接用它输入类类型数据
正确答案：C
-
第5题：
下面对C++运算符的正确的描述是( )。
A．只有类成员运算符
B．只有友元运算符
C．只有非成员和非友元运算符
D．上述三者都有
正确答案：D
-
第6题：
友元运算符obj1＞obj2被C++编译器解释为( )。
A．operator＞(obj1,obj2)
B．＞(obj1,obj2)
C．obj2.operator＞(obj1)
D．obj1.operator＞(obj2)
正确答案：A
-
第7题：
在C++ 程序中调用被C 编译器编译后的函数，
为什么要加extern “C”？
正确答案：首先，作为extern是C/C++语言中表明函数和全局
变量作用范围（可见性）的关键字，该关键字告诉
编译器，其声明的函数和变量可以在本模块或其它
模块中使用。
通常，在模块的头文件中对本模块提供给其它模块
引用的函数和全局变量以关键字extern声明。例如，
如果模块B 欲引用该模块A 中定义的全局变量和
函数时只需包含模块A的头文件即可。这样，模块
B中调用模块A中的函数时，在编译阶段，模块B
虽然找不到该函数，但是并不会报错；它会在连接
阶段中从模块A 编译生成的目标代码中找到此函
数
extern "C"是连接申明(linkage declaration),被extern
"C"修饰的变量和函数是按照C 语言方式编译和连
接的,来看看C++中对类似C的函数是怎样编译的：
作为一种面向对象的语言，C++支持函数重载，而
过程式语言C则不支持。函数被C++编译后在符号
库中的名字与C语言的不同。例如，假设某个函数
的原型为：
void foo( int x, int y );
该函数被C 编译器编译后在符号库中的名字为
_foo，而C++编译器则会产生像_foo_int_int之类的
名字（不同的编译器可能生成的名字不同，但是都
采用了相同的机制，生成的新名字称为“mangled
name”）。
_foo_int_int这样的名字包含了函数名、函数参数数
量及类型信息，C++就是靠这种机制来实现函数重
载的。例如，在C++中，函数void foo( int x, int y )
与void foo( int x, float y )编译生成的符号是不相同
的，后者为_foo_int_float。
同样地，C++中的变量除支持局部变量外，还支持
类成员变量和全局变量。用户所编写程序的类成员
变量可能与全局变量同名，我们以"."来区分。而本
质上，编译器在进行编译时，与函数的处理相似，
也为类中的变量取了一个独一无二的名字，这个名
字与用户程序中同名的全局变量名字不同。
未加extern "C"声明时的连接方式
假设在C++中，模块A的头文件如下：
// 模块A头文件moduleA.h
#ifndefMODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
在模块B中引用该函数：
// 模块B实现文件moduleB.cpp
＃i nclude "moduleA.h"
foo(2,3);
实际上，在连接阶段，连接器会从模块A生成的目
标文件moduleA.obj 中寻找_foo_int_int 这样的符
号！
加extern "C"声明后的编译和连接方式
加extern "C"声明后，模块A的头文件变为：
// 模块A头文件moduleA.h
#ifndefMODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
在模块B的实现文件中仍然调用foo( 2,3 )，其结果
是：
（1）模块A 编译生成foo 的目标代码时，没有对
其名字进行特殊处理，采用了C语言的方式；
（2）连接器在为模块B 的目标代码寻找foo(2,3)
调用时，寻找的是未经修改的符号名_foo。
如果在模块A中函数声明了foo为extern "C"类型，
而模块B中包含的是extern int foo( int x, int y ) ，
则模块B找不到模块A中的函数；反之亦然。
所以，可以用一句话概括extern “C”这个声明的真
实目的（任何语言中的任何语法特性的诞生都不是
随意而为的，来源于真实世界的需求驱动。我们在
思考问题时，不能只停留在这个语言是怎么做的，
还要问一问它为什么要这么做，动机是什么，这样
我们可以更深入地理解许多问题）：实现C++与C
及其它语言的混合编程。
明白了C++中extern "C"的设立动机，我们下面来
具体分析extern "C"通常的使用技巧：
extern "C"的惯用法
（1）在C++中引用C 语言中的函数和变量，在包
含C语言头文件（假设为cExample.h）时，需进行
下列处理：
extern "C"
{
＃i nclude "cExample.h"
}
而在C语言的头文件中，对其外部函数只能指定为
extern类型，C语言中不支持extern "C"声明，在.c
文件中包含了extern "C"时会出现编译语法错误。
C++引用C函数例子工程中包含的三个文件的源代
码如下：
/* c语言头文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c语言实现文件：cExample.c */
＃i nclude "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++实现文件，调用add：cppFile.cpp
extern "C"
{
＃i nclude "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
如果C++调用一个C 语言编写的.DLL 时，当包
括.DLL 的头文件或声明接口函数时，应加extern
"C" { }。
（2）在C中引用C++语言中的函数和变量时，C++
的头文件需添加extern "C"，但是在C语言中不能
直接引用声明了extern "C"的该头文件，应该仅将C
文件中将C++中定义的extern "C"函数声明为
extern类型。
C引用C++函数例子工程中包含的三个文件的源代
码如下：
//C++头文件cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++实现文件cppExample.cpp
＃i nclude "cppExample.h"
int add( int x, int y )
{
return x + y;
}
/* C实现文件cFile.c
/* 这样会编译出错：＃i nclude "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
} -
第8题：
在 C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明？
正确答案：
-
第9题：
include<iostream>
include<string>
using namespace std;
class MyClass
{
public:
MyClass(int i=0){member=i;}
void SetMember(const string m){member="big"+m;m=member;}
string GetMember(){return member;}
void print()const{cout<<"Stu:"<<member<<endl;}
private:
string member;
};
void main()
{
MyClass obj1,*obj2;
string i="wang lin";
obj2=&obj1;
obj2->SetMember(i);
obj1.print();
}
正确答案：
voidSetMember(conststringm){member=”big”+m;m=member;}。const修饰符的形参不能改变。应删去const或者删去m=member。 -
第10题：
下面运算符不能被友元函数重载的是( )。
A．+
B．=
C．*
D．＜＜
正确答案：B
解析：=,(),[],-＞运算符不能够重载为类的友元函数。 -
第11题：
C++语言允许使用友元，但是友元会破坏封装性。
正确答案:正确 -
第12题：
单选题在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。A作为友元函数重载的1元运算符
B作为成员函数重载的1元运算符
C作为友元函数重载的2元运算符
D作为成员函数重载的2元运算符
正确答案： A解析： 暂无解析 -
第13题：
关于下面程序段说法正确的是()。class X { private: int n; public: X(X&); }; X::X(X&x) {n=x.n} X obj1,obj2(obj1);A.语句obj2(obj1);的功能是用对象obj2初始化具有相同类类型的对象obj1
B.语句obj2(obj1);的功能是用对象obj1初始化具有相同类类型的对象obj2
C.X(X&x)函数中不能访问对象的私有成员
D.X(X&x)中的&符号可以删除
正确答案：B
-
第14题：
C＋＋中,能够被派生类继承的函数是( )。A. 析构函数
B.成员函数
C.构造函数
D.友元函数
参考答案：B
-
第15题：
下面关于成员函数重载运算符和友元函数重载运算符相同的是( )。
A．成员函数和友元函数可重载的运算符是不相同的
B．成员函数和友元函数重载运算符时都需要用到this指针
C．成员函数和友元函数重载运算符时都需要声明为公有的
D．成员函数和友元函数重载运算符时的参数可能是相同的
正确答案：A
-
第16题：
当+运算符被重载为非静态成员函数时，成员运算符objl+obj2被C++编译器解释为 ______。
A．operator+(obj1，obj2)
B．+(obj1,obj2)
C．obj2.operator+(obj1)
D．obj1.operator+(obj2)
正确答案：D
-
第17题：
以下程序的执行结果是______。 includeclass base { public: virtual void who(){c 以下程序的执行结果是______。
include＜iostream.h＞
class base
{
public：
virtual void who(){cout＜＜"base class"＜＜endl：}
}；
class derrvel:public base
{
public：
void who(){cout＜＜"derivel class"＜＜endl：}
};
class derive2；public base
{
public：
void who() {cout＜＜"derive2 class"＜＜endl；}
}；
void main()
{
base obj1，*P；
derive1 obj2；
derive2 obj3：
p=&obj1；
p-＞who()；
p=&obj2：
p-＞who()；
p=&obj3；
p-＞who()；
}
正确答案：base class derivel class derive2 class
base class derivel class derive2 class -
第18题：
若有一个MyClass类，则执行语句“MyClass obj1，obj2[2]，*p；”后，自动调用该类的构造函数( )次。
A．2
B．3
C．4
D．5
正确答案：B
解析：本题考核构造函数的调用。C++在创建一个对象时，会自动调用类的构造函数， 在构造函数中可以执行初始化成员变量的操作。语句“MyClass obj1，obj2[2]，*p；”创建了3个对象。obj1、obj2[0]、obj2[1]和一个对象指针。在创建。obj1、 obj2[0]、obj2[1]对象时系统会调用类的构造函数。但在创建对象指针p时，不调用类的构造函数，因为指针p本身不定义类对象，而是定义了p可以指向一个MyClass的对象。 -
第19题：
有以下程序： #include<iostream> usingnamespaeestd； classMyClass { public： MyClass(intn){number=n；} ／／拷贝构造函数 MyClass(MyClass＆other){number=other．number；} ～MyClass（）{} private： intnumber； }； MyClassfun(MyClassp) { MyClasstemp(p)； returntemp； } intmain（） { MyCIassobj1(10)，obj2(O)； MyClassobj3(obj1)； obj2=fun(obj3)； return0； 程序执行时，MyClass类的拷贝构造函数被调用的次数是（ ）。
A.5
B.4
C.3
D.2
正确答案：B
B。【解析】调用拷贝构造函数的情况为：一个新对象被另一个已存在的同类型对象初始化；当一个对象作为实参传递给函数时为初始化形参，要调用拷贝构造函数。在函数值返回时形参的生命期结束时它的析构函数被调用；在函数返回一个对象时调用拷贝构造函数。符合以上条件的有：用对象objl来初始化obj3；obj3作为实参被传入；函数fun返回一个对象时；系统用返回值初始化一个匿名对象时调用了拷贝构造函数。总共调用4次。 -
第20题：
C/C++编译器中虚表是如何完成的？
正确答案：
-
第21题：
当+运算符被重载为友元函数时，友元运算符Obj1+obj2被C++编译器解释为 ______。
A．operator+(objl, obj2)
B．+(obj1, obj2)
C．obj2.operator+(obj1)
D．obj1,operator(obj2)
正确答案：A
-
第22题：
下列程序编译错误,是由于划线处缺少某个语句,该语句是______。 includeclass A { pr 下列程序编译错误，是由于划线处缺少某个语句，该语句是______。
include＜iostream.h＞
class A
{
private:
int numl;
public:
A( ):numl(0){}
A(int i):numl(i){}
};
class B
{
private:
int num2;
public:
B( ):num2(0){}
B(int i):num2(i){}
int my_math(A obj1, B obj2);
};
int B::my_math(A obj1,B obj2)
{
return(obj1.numl+obj2.num2);
}
void main(void)
{
A objl(4);
B obj,obj2(5);
cout＜＜"obj1+obj2:"＜＜obj.my_math(obj1,obj2);
}
正确答案：friend class B;
friend class B; 解析：在B类中出现了对A类中私有成员numl的直接访问，这是不允许的。所以必须要把类B设成类A的友员才可以通过编译。 -
第23题：
判断题C++语言允许使用友元，但是友元会破坏封装性。A对
B错
正确答案： 错解析： 暂无解析 -
第24题：
单选题设有类A的对象Aobject，若用成员函数重载前置自增表达式，那么++Aobject被编译器解释为（）AAobject.operator++（）
Boperator++（Aobject）
C++（Aobject）
DAobject：：operator++（）
正确答案： B解析： 暂无解析