zoukankan      html  css  js  c++  java
  • C++重点知识

    来源:http://www.cnblogs.com/lzjsky/archive/2011/01/18/1938507.html

    2. 什么是“引用”?申明和使用“引用”要注意哪些问题?

        答:引用就是某个目标变量的“别名”(alias),对引用的操作与对变量直接操作效果完全相同。申明一个引用的时候,切记要对其进行初始化。引用声明完 毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,不能再把该引用名作为其他变量名的别名。声明一个引用,不是新定义了一个变量,它只表示该引 用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。不能建立数组的引用。

        3. 将“引用”作为函数参数有哪些特点?

        (1)传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。

        (2)使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存 储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空 间都好。

        (3)使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名" 的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。而引用更容易使用,更清晰。

        4. 在什么时候需要使用“常引用”?

        如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。常引用声明方式:const 类型标识符 &引用名=目标变量名;

        例1

    int a ;
    const int &ra=a;
    ra=1; //错误
    a=1; //正确

        例2

    string foo( );
    void bar(string & s);
    那么下面的表达式将是非法的:
    bar(foo( ));
    bar("hello world");

        原因在于foo( )和"hello world"串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。

        引用型参数应该在能被定义为const的情况下,尽量定义为const .

    5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

        格式:类型标识符 &函数名(形参列表及类型说明){ //函数体 }好处:在内存中不产生被返回值的副本;(注意:正是因为这点原因,所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束,相应的引用 也会失效,产生runtime error!

        注意事项:

        (1)不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31.主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指"的引用,程序会进入未知状态。

        (2)不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31.虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部new分配内存的引用),又面临其它尴尬局面。例如,被函数返回的引用只是作为一 个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由new分配)就无法释放,造成memory leak.(3)可以返回类成员的引用,但最好是const.这条原则可以参照Effective C++[1]的Item 30.主要原因是当对象的属性是与某种业务规则(business rule)相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。

        (4)流操作符重载返回值申明为“引用”的作用:流操作符<<和>>,这两个操作符常常希望被连续使用,例如:cout << "hello" << endl; 因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括:返回一个流对象和返回一个流对象指针。但是对于返回 一个流对象,程序必须重新(拷贝)构造一个新的流对象,也就是说,连续的两个<<操作符实际上是针对不同对象的!这无法让人接受。对于返回一 个流指针则不能连续使用<<操作符。因此,返回一个流对象引用是惟一选择。这个唯一选择很关键,它说明了引用的重要性以及无可替代性,也许这 就是C++语言中引入引用这个概念的原因吧。赋值操作符=.这个操作符象流操作符一样,是可以连续使用的,例如:x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值,以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

        例3

    #i nclude <iostream.h>
    int &put(int n);
    int vals[10];
    int error=-1;
    void main()
    {
    put(0)=10; //以put(0)函数值作为左值,等价于vals[0]=10;
    put(9)=20; //以put(9)函数值作为左值,等价于vals[9]=20;
    cout<<vals[0];
    cout<<vals[9];
    }
    int &put(int n)
    {
    if (n>=0 && n<=9 ) return vals[n];
    else { cout<<"subscript error"; return error; }
    }

        (5)在另外的一些操作符中,却千万不能返回引用:+-*/ 四则运算符。它们不能返回引用,Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect,因此,它们必须构造一个对象作为返回值,可选的方案包括:返回一个对象、返回一个局部变量的引用,返回一个new分配的对象的引用、返回一 个静态对象引用。根据前面提到的引用作为返回值的三个规则,第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

        6. “引用”与多态的关系?

        引用是除指针外另一个可以产生多态效果的手段。这意味着,一个基类的引用可以指向它的派生类实例。

        例4

    Class A; Class B : Class A{...};  B b; A& ref = b;

        7. “引用”与指针的区别是什么?

        指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。程序中使用指针,程序的可读性差;而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作。此外,就是上面提到的对函数传ref和pointer的区别。

        8. 什么时候需要“引用”?

        流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

        以上 2-8 参考:http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx

    18. 重载(overload)和重写(overried,有的书也叫做“覆盖”)的区别?

        常考的题目。从定义上来说:重载:是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。

        重写:是指子类重新定义复类虚函数的方法。

        从实现原理上来说:重载:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如, 有两个同名函数:function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的:int_func、str_func.对于这两个函数的 调用,在编译器间就已经确定了,是静态的。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!

        重写:和多态真正相关。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(晚绑定)。

    19. 多态的作用?

        主要是两个:1. 隐藏实现细节,使得代码能够模块化;扩展代码模块,实现代码重用;2. 接口重用:为了类在继承和派生的时候,保证使用家族中任一类的实例的某一属性时的正确调用。

    24. C++是不是类型安全的?

        答案:不是。两个不同类型的指针之间可以强制转换(用reinterpret cast)。C#是类型安全的。

    25. main 函数执行以前,还会执行什么代码?

        答案:全局对象的构造函数会在main 函数之前执行。

        26. 描述内存分配方式以及它们的区别?

        1)从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。

        2)在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

        3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定,使用非常灵活,但问题也最多。

    27.struct 和 class 的区别答案:struct 的成员默认是公有的,而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。

        从感情上讲,大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位,而类就象活的并且可靠的社会成员,它有智能服 务,有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为,那么只有在你的类有很少的方法并且有公有数据(这种事情在良好设计的系统中是存在 的!)时,你也许应该使用 struct 关键字,否则,你应该使用 class 关键字。

    29. 在8086 汇编下,逻辑地址和物理地址是怎样转换的?(Intel)

        答案:通用寄存器给出的地址,是段内偏移地址,相应段寄存器地址*10H+通用寄存器内地址,就得到了真正要访问的地址。

        30. 比较C++中的4种类型转换方式?

        请参考:http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx ,重点是static_cast, dynamic_cast和reinterpret_cast的区别和应用

    32.请说出const与#define 相比,有何优点?

        答案:1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误。

        2) 有些集成化的调试工具可以对const 常量进行调试,但是不能对宏常量进行调试。

    34.类成员函数的重载、覆盖和隐藏区别?

        答案:

        a.成员函数被重载的特征:

        (1)相同的范围(在同一个类中);(2)函数名字相同;(3)参数不同;(4)virtual 关键字可有可无。

        b.覆盖是指派生类函数覆盖基类函数,特征是:

        (1)不同的范围(分别位于派生类与基类);(2)函数名字相同;(3)参数相同;(4)基类函数必须有virtual 关键字。

        c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:

        (1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。

        (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual 关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)

    37. main 主函数执行完毕后,是否可能会再执行一段代码,给出说明?

        答案:可以,可以用_onexit 注册一个函数,它会在main 之后执行int fn1(void), fn2(void), fn3(void), fn4 (void);

    void main( void )
    {
    String str("zhanglin");
    _onexit( fn1 );
    _onexit( fn2 );
    _onexit( fn3 );
    _onexit( fn4 );
    printf( "This is executed first.\n" );
    }
    int fn1()
    {
    printf( "next.\n" );
    return 0;
    }
    int fn2()
    {
    printf( "executed " );
    return 0;
    }
    int fn3()
    {
    printf( "is " );
    return 0;
    }
    int fn4()
    {
    printf( "This " );
    return 0;
    }
    The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.

    44. 多重继承的内存分配问题:比如有class A : public class B, public class C {}那么A的内存结构大致是怎么样的?

        这个是compiler-dependent的, 不同的实现其细节可能不同。

        如果不考虑有虚函数、虚继承的话就相当简单;否则的话,相当复杂。

        可以参考《深入探索C++对象模型》,或者:http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx

      45. 如何判断一个单链表是有环的?(注意不能用标志位,最多只能用两个额外指针)

        struct node { char val; node* next;}

         bool check(const node* head) {} //return false : 无环;true: 有环

        一种O(n)的办法就是(搞两个指针,一个每次递增一步,一个每次递增两步,如果有环的话两者必然重合,反之亦然):

    bool check(const node* head)
    {
        if(head==NULL)  return false;
        node *low=head, *fast=head->next;
        while(fast!=NULL && fast->next!=NULL)
        {
            low=low->next;
            fast=fast->next->next;
            if(low==fast) return true;
        }
        return false;
    }

    1. 是不是一个父类写了一个 virtual 函数,如果子类覆盖它的函数不加 virtual , 也能实现多态 ?

        virtual 修饰符会被隐形继承的。

        private 也被集成,只事派生类没有访问权限而已virtual 可加可不加子类的空间里有父类的所有变量 (static 除外 )

        同一个函数只存在一个实体 (inline 除外 )

        子类覆盖它的函数不加 virtual , 也能实现多态。

        在子类的空间里,有父类的私有变量。私有变量不能直接访问。

    3. 请简单描述 Windows 内存管理的方法。

        内存管理是操作系统中的重要部分,两三句话恐怕谁也说不清楚吧~~我先说个大概,希望能够抛砖引玉吧当程序运行时需要从内存中读出这段程序的代码。代码的 位置必须在物理内存中才能被运行,由于现在的操作系统中有非常多的程序运行着,内存中不能够完全放下,所以引出了虚拟内存的概念。把哪些不常用的程序片断 就放入虚拟内存,当需要用到它的时候在 load 入主存(物理内存)中。这个就是内存管理所要做的事。内存管理还有另外一件事需要做:计算程序片段在主存中的物理位置,以便 CPU 调度。

        内存管理有块式管理,页式管理,段式和段页式管理。现在常用段页式管理块式管理:把主存分为一大块、一大块的,当所需的程序片断不在主存时就分配一块主存 空间,把程 序片断 load 入主存,就算所需的程序片度只有几个字节也只能把这一块分配给它。这样会造成很大的浪费,平均浪费了 50 %的内存空间,但时易于管理。

        页式管理:把主存分为一页一页的,每一页的空间要比一块一块的空间小很多,显然这种方法的空间利用率要比块式管理高很多。

        段式管理:把主存分为一段一段的,每一段的空间又要比一页一页的空间小很多,这种方法在空间利用率上又比页式管理高很多,但是也有另外一个缺点。一个程序 片断可能会被分为几十段,这样很多时间就会被浪费在计算每一段的物理地址上(计算机最耗时间的大家都知道是 I/O 吧)。

        段页式管理:结合了段式管理和页式管理的优点。把主存分为若干页,每一页又分为若干段。好处就很明显,不用我多说了吧。

        各种内存管理都有它自己的方法来计算出程序片断在主存中的物理地址,其实都很相似。

        这只是一个大概而已,不足以说明内存管理的皮毛。无论哪一本操作系统书上都有详细的讲解

    2. 以下代码中的两个sizeof用法有问题吗?[C易]

    void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
    {
        for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )
            if( 'a'<=str[i] && str[i]<='z' )
                str[i] -= ('a'-'A' );
    }
    char str[] = "aBcDe";
    cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
    UpperCase( str );
    cout << str << endl;

        答:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个 静态定义的数组,因此其大小为6,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此siz eof作用于上只将其当指针看,一个指针为4个字节,因此返回4.

    3. 非C++内建型别 A 和 B,在哪几种情况下B能隐式转化为A?[C++中等]

        答:   

        a. class B : public A { ……} // B公有继承自A,可以是间接继承的

        b. class B { operator A( ); } // B实现了隐式转化为A的转化

        c. class A { A( const B& ); } // A实现了non-explicit的参数为B(可以有其他带默认值的参数)构造函数

        d. A& operator= ( const A& ); // 赋值操作,虽不是正宗的隐式类型转换,但也可以勉强算一个

    4. 以下代码有什么问题?[C++易]

    struct Test
    {
        Test( int ) {}
        Test() {}
        void fun() {}
    };
    void main( void )
    {
        Test a(1);
        a.fun();
        Test b();
        b.fun();
    }

        答:变量b定义出错。按默认构造函数定义对象,不需要加括号。

        5. 以下代码有什么问题?[C++易]

    cout << (true?1:"1") << endl;

        答:三元表达式“?:”问号后面的两个操作数必须为同一类型。

        6. 以下代码能够编译通过吗,为什么?[C++易]

    unsigned int const size1 = 2;
    char str1[ size1 ];
    unsigned int temp = 0;
    cin >> temp;
    unsigned int const size2 = temp;
    char str2[ size2 ];

        答:str2定义出错,size2非编译器期间常量,而数组定义要求长度必须为编译期常量。

    7. 以下反向遍历array数组的方法有什么错误?[STL易]

    vector array;
    array.push_back( 1 );
    array.push_back( 2 );
    array.push_back( 3 );
    for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍历array数组
    {
        cout << array[i] << endl;
    }

        答:首先数组定义有误,应加上类型参数:vector<int> array.其次vector::size_type被定义为unsigned int,即无符号数,这样做为循环变量的i为0时再减1就会变成最大的整数,导致循环失去控制 .

        8. 以下代码中的输出语句输出0吗,为什么?[C++易]

    struct CLS
    {
        int m_i;
        CLS( int i ) : m_i(i) {}
        CLS()
        {
            CLS(0);
        }
    };
    CLS obj;
    cout << obj.m_i << endl;

        答:不能。在默认构造函数内部再调用带参的构造函数属用户行为而非编译器行为,亦即仅执行函数调用,而不会执行其后的初始化表达式。只有在生成对象时,初始化表达式才会随相应的构造函数一起调用。

        9. C++中的空类,默认产生哪些类成员函数?[C++易]

        答:

    class Empty
    {
    public:
        Empty();                          // 缺省构造函数
        Empty( const Empty& );            // 拷贝构造函数
        ~Empty();                         // 析构函数
        Empty& operator=( const Empty& ); // 赋值运算符
        Empty* operator&();               // 取址运算符
        const Empty* operator&() const;   // 取址运算符 const
    };

        10. 以下两条输出语句分别输出什么?[C++难]

    float a = 1.0f;
    cout << (int)a << endl;
    cout << (int&)a << endl;
    cout << boolalpha << ( (int)a == (int&)a ) << endl; // 输出什么?
    float b = 0.0f;
    cout << (int)b << endl;
    cout << (int&)b << endl;
    cout << boolalpha << ( (int)b == (int&)b ) << endl; // 输出什么?

        答:分别输出false和true.注意转换的应用。(int)a实际上是以浮点数a为参数构造了一个整型数,该整数的值是1,(int&)a则 是告诉编译器将a当作整数看(并没有做任何实质上的转换)。因为1以整数形式存放和以浮点形式存放其内存数据是不一样的,因此两者不等。

        对b的两种转换意义同上,但是0的整数形式和浮点形式其内存数据是一样的,因此在这种特殊情形下,两者相等(仅仅在数值意义上)。

        注意,程序的输出会显示(int&)a=1065353216,这个值是怎么来的呢?前面已经说了,1以浮点数形式存放在内存中,按 ieee754规定,其内容为0x0000803F(已考虑字节反序)。这也就是a这个变量所占据的内存单元的值。当(int&)a出现时,它相 当于告诉它的上下文:“把这块地址当做整数看待!不要管它原来是什么。”这样,内容0x0000803F按整数解释,其值正好就是 1065353216(十进制数)。

        通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说,而(in t&)的作用则仅仅是表达了一个类型信息,意义在于为cout<<及==选择正确的重载版本。

        11. 以下代码有什么问题?[STL易]

    typedef vector IntArray;
    IntArray array;
    array.push_back( 1 );
    array.push_back( 2 );
    array.push_back( 2 );
    array.push_back( 3 );
    // 删除array数组中所有的2
    for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )
    {
        if( 2 == *itor ) array.erase( itor );
    }

        答:同样有缺少类型参数的问题。另外,每次调用“array.erase( itor );”,被删除元素之后的内容会自动往前移,导致迭代漏项,应在删除一项后使itor——,使之从已经前移的下一个元素起继续遍历。

        12. 写一个函数,完成内存之间的拷贝。[考虑问题是否全面]

        答:

    void* mymemcpy( void *dest, const void *src, size_t count )
    {
        char* pdest = static_cast<char*>( dest );
        const char* psrc = static_cast<const char*>( src );
        if( pdest>psrc && pdest<psrc+cout ) 能考虑到这种情况就行了
        {
            for( size_t i=count-1; i!=-1; --i )
                    pdest[i] = psrc[i];
        }
        else
        {
            for( size_t i=0; i<count; ++i )
                pdest[i] = psrc[i];
        }
        return dest;

    分类: c/c++, 面試


    微信公众号: 猿人谷
    如果您认为阅读这篇博客让您有些收获,不妨点击一下右下角的【推荐】
    如果您希望与我交流互动,欢迎关注微信公众号
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接。

  • 相关阅读:
    HDU 3572 Task Schedule(拆点+最大流dinic)
    POJ 1236 Network of Schools(Tarjan缩点)
    HDU 3605 Escape(状压+最大流)
    HDU 1166 敌兵布阵(分块)
    Leetcode 223 Rectangle Area
    Leetcode 219 Contains Duplicate II STL
    Leetcode 36 Valid Sudoku
    Leetcode 88 Merge Sorted Array STL
    Leetcode 160 Intersection of Two Linked Lists 单向链表
    Leetcode 111 Minimum Depth of Binary Tree 二叉树
  • 原文地址:https://www.cnblogs.com/heyonggang/p/3042524.html
Copyright © 2011-2022 走看看