小胖子吃辣肉面的专栏

<br />    A. operator +()<br />    B. operator ++()<br />    C. operator ==()<br />    D. operator ()()<br />    E. operator []()<br /><br /><br /><br />D  function object

<br />    A. Default arguments cannot be of pointer type.<br />    B. Default arguments cannot be of a user-defined type.<br />    C. Default arguments can never precede non-default arguments.<br />    D. Default arguments exist in the global heap and not

<br />    A. The base class destructor calls the virtual function override of the derived class through the vtable.<br />    B. The base class destructor cannot call the virtual function override of the derived class because the derived class portion of th

<br />    A. It only flushes the standard output stream.<br />    B. It puts a newline character into the standard output stream and flushes the standard output stream.<br />    C. It puts an end-of-output character into the standard output stream.<br />  

<br />    A. When there is a looping construct that uses a continue more than once<br />    B. When there is a need for the code written today to call code written tomorrow<br />    C. When there is a need to check for the type of an object to determine wh

<br />    A. setbuffer<br />    B. setfilebuf<br />    C. rdbuf<br />    D. filebuf<br />    E. streambuf

<br />    A. #define MESSAGE "Whoever said that you could run this program" &<br />"must not have known what you'd do."<br />    B. #define GREETING = "Hello!"<br />    C. #define MESSAGE = "This is a long message, but I know you have"<br />#define MESSAGE

<br />    A. std::basic_istream<wchar_t, char_traits<wchar_t> ><br />    B. std::basic_istream<char, char_traits<char> ><br />    C. std::istream<char, char_traits<char> ><br />    D. std::istream<wchar_t, char_traits<wchar_t> ><br />    E. std::wistream<c

<br />A. ~Y()   ~X()   ~A()<br />B. ~X()   ~A()   ~Y()<br />C. ~Y()   ~A()   ~X()<br />D. ~A()   ~Y()   ~X()<br />E. ~X()   ~Y()   ~A()<br /><br /><br />C<br /><br /><br />构造函数调用次序： 基类构造函数（按申明顺序）  派生类成员变量构造函数   派生类自己构造函数<br /><br />析构函数调用次序： 与基类完全相反

<br />class Base{ public: Base(){cout << "In Base Ctor/n";} class Nest { public: Nest(){cout << "In Nest Ctor/n"; } }; };class Derive : public Base{ public: Derive(){cout << "In De

<br />#include <iostream>using namespace std;class Object{public: Object() {} void Print() const { cout << "const" << endl; } void Print() { cout << "mutable" << endl; }};void pri

<br />#include <iostream>class TestPrint{public: void Print() { std::cout << "TestPrint" << std::endl; } void Print() const { std::cout << "const TestPrint" << std::endl; } void Print() vol

<br />#include <iostream>class Outer{ int m_o; public: class Inner { int m_i; public: Inner(){} Inner(Outer m_outer, int x) { m_outer.m_o = x; } }; Outer(int y)

<br />    A. Has-a<br />    B. Is-implemented-in-terms-of<br />    C. Was-a<br />    D. Can-only-have-one-of<br />    E. Shares-a-relationship-with<br /><br /><br />B

<br />    A. new SomeClass(pmem);<br />    B. new(pmem) SomeClass;<br />    C. new pmem SomeClass;<br />    D. new SomeClass pmem;<br />    E. new (pmem, SomeClass);<br /><br /><br />B

<br />class String {<br />public:<br />   //...<br />   //declaration goes here<br />};<br /> <br />    A. char* operator();<br />    B. char* operator char*();<br />    C. String operator char*();<br />    D. operator char*();<br />    E. char* operator S

<br />class SomeClass{ public: int data; protected: class Nest { public: int nested; }; public: static Nest* createNest(){return new Nest;}};void use_someclass()

<br /> <br />    A. Once an exception is thrown, the compiler unwinds the heap, freeing any memory dynamically allocated within the block from which the exception was thrown.<br />    B. In a hierarchy of exception classes, the order of handling exceptions

<br />    A. A reference to a const std::type_info object<br />    B. A const std::type_info object<br />    C. A const reference to a const std::type_info object<br />    D. A reference to a std::type_info object<br />    E. A const reference to a std::ty

template void fn(T a){...}Which of the following methods can the developer use to carry out this specialization?    A. void fn(char* a){...}    B. template void fn(char* a){...}    C. void fn(T a){...}    D. template void fn(char* a){...}    E. template

<br />int *(*p)[5];<br /> <br />Which of the following statements can be used to allocate memory for the first dimension in order to make p an array of 3 arrays of 5 pointers to type int?<br /> <br />    A. p = new int [3][5]*;<br />    B. p = new int (*)[

    A. It calls the class default constructor for each element of the array.    B. It calls the class copy constructor for each element of the array.    C. It calls operator new[](size_t).    D. It calls operator new[](size_t, int).    E. It stores the num

    A. It can invoke the terminate() handler.    B. Since the object is being destroyed, it is illogical to throw an exception then.    C. The C++ language does not permit it; a throw statement in a destructor will be caught as an error by the compiler.   

<br />A. Every object of the class holds the address of a structure holding the addresses of the 5 virtual functions.<br />    B. Every object of the class holds the addresses of the 5 virtual functions.<br />    C. Every object of the class holds the addr

#define language 437            //Line 1#if language #undef language                 //Line 2#else                           //Line 3#define language 850            //Line 4#ifdef language                 //Line 5   printf("%d", language);      //Line 6#en

<br />    A. friend<br />    B. static<br />    C. extern<br />    D. inline<br />    E. member<br /><br /> <br /><br />D

<br />    A. void tellg(pos_type&)<br />    B. pos_type tellg()<br />    C. pos_type tellp()<br />    D. void tellp(pos_type&)<br />    E. void seekg(pos_type&)

A. RTTI does not have standardized run-time behavior. B. RTTI uses too much memory. C. RTTI is too slow. D. RTTI's performance is unpredictable/non-deterministic. E. RTTI frequently fails to function correctly at run-time.B C

    A. std::allocator::allocate(size_t)    B. std::allocator::malloc(int)    C. std::allocator::make(size_t)    D. std::allocator::new(size_t)    E. std::allocator::acquire(size_t)

A. Write the terminate() function with two int arguments. B. Write the terminate() function with a runtime_error argument. C. Pass the address of the overriding function to the set_terminate() function. D. Write the terminate() function with one

<br />A. It throws a bad_alloc exception.<br />B. It returns null.<br />C. It returns silently with no effect on the expression.<br />D. It throws an insufficient_memory exception.<br />E. It logs an error message to the mem_err.log file.<br /><br /><br />

#include #include //Someone else's code, e.g. libraryclass IGlyph{public: virtual ~IGlyph(){} virtual std::string Text()=0; virtual IIcon* Icon()=0; //...};class IWidgetSelector{public: virtual ~IWidgetSe

<br />    A. When no conversion function exists for converting the class object to another class object<br />    B. When an existing object is assigned an object of its own class<br />    C. When a function receives as an argument, an object of the class,

<br />A. A preprocessor macro expansion cannot work when user-defined types are passed to it as arguments.<br />B. Since the preprocessor does the macro expansion and not the compiler, the build process takes a longer period of time.<br />C. While expandin

A. The getline() function by default, accepts whitespace, and returns on seeing the /n character, whereas the extraction operator returns when it encounters any whitespace character.    B. Delimiters indicating end of input can be specified to the getline(

<br />template <class T> class Derived;<br /> <br />that has to inherit from another template class<br /> <br />template <class T> class Base;?<br /> <br />    A. template <class T, class Q> class Derived<Q> : public Base<T><br />    where Q can be used as

<br />    A. #ifndef<br />    B. #ifdef<br />    C. #elif<br />    D. #define<br />    E. #extern<br /><br /> <br />E

<br />void main()<br />{<br />   const int Mon = 1, Tue = 2;<br />   enum DOW{ Mon = 11, Tue = 12 };<br />   ...<br /> <br />    A. The variable var will have to be of type enum DOW, and then defined as:<br /> <br />var = Mon;<br />    B. Mon of enum DOW c

templateclass MyArray{public: MyArray(); MyArray(MyArray& copy); MyArray& operator=(MyArray& copy); //...};class MyData{public: MyData(MyArray& x, MyArray& y); //... const MyArray& x(); const MyArray&

int var = 1;void main(){    int i = i;}    A. The i within main will have an undefined value.    B. The compiler will allow this statement, but the linker will not be able to resolve the declaration of i.    C. The i within main will have a value of 1.