牛客网 刷题笔记2017年1月19日

内联函数和宏的区别

1. 内联函数在编译的时候可以调试，而宏不可以。
2. 内联函数会对参数类型做安全检查或自动转换，而宏不会。
3. 内联函数是需要消耗内存的，而宏是字符串替换，所以不占用内存。
4. 内联函数可以访问类成员变量，而宏则不可以。
5. 在类中声明同时定义成员函数，自动转化为内联函数。

快速排序

1. 实现是基于分治算法。
2. 分解 解决 合并，每次分解为两个数组，需要logn次划分。
3. 快速排序的效率取决于递归次数(深浅)。
4. 最坏的情况，即数组有序或大致有序的情况下，每次划分只能减少一个元素，快速排序的下界为O(n^2),在实际运用中，时间快排的平均复杂度为O（nlogn）

时间复杂度计算

在一台主流配置的PC机上，调用f(35)所需的时间大概是_。
几分钟

int f(int x) {
int s=0;
while(x– >0) s+=f(x);
return max(s,1);
}
O(f(n))=O(f(n-1))+O(f(n-2))+…+O(f(n))
= 2O(f(n-2))+2O(f(n-3))+…+2O(f(n))
= 2^35O(f(n))
2^35/10 000 000 ~~几分钟

flag&=~2
~2 1111 11101 取反在与

1. 运行结果

#include<iostream>
using namespace std;
class TestClass{
    char x;
public:
    TestClass() { cout << 'A'; }
    TestClass(char c) { cout << c; }
    ~TestClass() { cout << 'B'; }
};
int main() {
    TestClass p1, *p2;
    p2 = new TestClass('X');
    delete p2;
    return 0;
}

执行这个程序的结果是（）
声明类，调用默认构造函数
指针的声明，不会调用构造函数，但是指针指向new实例，就会调用构造函数。
TestClass p1, *p2; 、、 p1调用默认构造函数 ‘A’
p2 = new TestClass(‘X’); p2 调用构造函数X
delete p2; 调用析构函数 ‘B’
return 0; P1调用析构函数 ‘B’

如下代码输出结果是什么？

#include<stdio.h>
char *myString()
{
    char buffer[6] = {0};
    char *s = "Hello World!";
    for (int i = 0; i < sizeof(buffer) - 1; i++)
    {
        buffer[i] = *(s + i);
    }
    return buffer;
}
int main(int argc, char **argv)
{
    printf("%s\n", myString());
    return 0;
}

在mystring()中没有malloc()或者new() ,所有buffer数组的内存区域是栈，函数结束时，栈区释放内存，字符数组也就不复存在，所以会产生野指针，返回值未知。

class CParent 
{
    public: virtual void Intro()
    {
        printf( "I'm a Parent, " ); Hobby();
    }
    virtual void Hobby()
    {
        printf( "I like football!" );
    }
}; 
class CChild : public CParent { 
    public: virtual void Intro()
    {
        printf( "I'm a Child, " ); Hobby();
    }
    virtual void Hobby()
    {
       printf( "I like basketball!\n" );
    }
}; 
int main( void )
{
    CChild *pChild = new CChild(); 
    CParent *pParent = (CParent *) pChild; 
    pParent->Intro(); 
    return(0);
}

通过指针访问虚函数，基类会在派生类中寻找，先执行派生类中的函数。
I’m a Child I like basketball!