笔试2：禾赛科技

静态局部变量概念。

继承体系中派生类构造函数的调用，虚函数机制。

数组名取地址的意义以及指针常量和常量指针的概念。

指针常量指的是指针指向的内容不可变；常量指针指的是指针本身不可变。

解释：(int)(pf[8])(double *);

自定义string类，并实现构造函数、赋值运算符函数(要求能够输入任意二进制字符，即非法字符串和‘\0’)

class MyString
{
public:
    MyString();
    MyString(const char *s);    //构造函数
    MyString(const char *s, int l);
    MyString& operator = (const MyString &st);    //赋值运算符
    friend ostream&operator<<(ostream &os,const MyString&st){os<<st.str;return os;}
private:
    char *str;    //字符串
    int len;       //字符串长度
}
MyString::MyString(const char *s)
{
    len = strlen(str);
    str = new char[len+1];
    strcpy(str,s);
}

MyString::MyString(const char *s, int l)
{
    len = l;
    str = new char[len + 1];
    for (int i = 0; i < l + 1; ++i)
    {
        str[i] = s[i];
    }
}

MyString& MyString::operator=(const MyString & st)
{
    if(this==&st)
        return *this;
    delete []str;    //清空内存
    len = st.len;
    str = new char[len+1];
    strcpy(str,st.str);
    return *this;
}

关于\0的讨论：
从const char*创建string时，指针指向的数组必须以空字符结尾，拷贝操作遇到空字符时停止。如果传递给构造函数一个计数值，数组就不必以空字符结尾。
标准string的构造函数string::basic_string(const char *_Ptr,size_t _Count);可以实现如下操作：

char *s = "abcde\0fg";
string str(s,9);
cout<<str<<endl;    //输出：abcde  fg

然而上面重载构造函数，虽然能够将"abcde\0fg"传递给str成员，但是重载的<<又不能像标准string一样直接输出。

vector容器自定义排序算法，相关结构体如下：

struct Student{
string name;
string class;
bool male;
double score;
};
extern vector<Student>vecStudent;    //所有学生信息

要求相同班级同学在一起；每个班中女在前男在后，按照分数降序排序，如果分数相同则按照姓名首字母字典序排列。完成排序后打印前n个同学的姓名和分数。

小端电脑，将一个浮点数按照大端模式放在buffer中发送出去，实现转换函数。

unsigned char buffer[4]={0};
void convert(float a,unsigned char buffer[]);

约瑟夫环问题。

唔，剑指offer用std::list的方式在牛客里面超时了。

int ysf(int n, int m)
{
    if (n < 0 || m < 1)
        return 0;
    list<int>st;
    for (int i = 1; i <= n; ++i)
        st.emplace_back(i);
    auto iter = st.begin();
    while (st.size() > 1)
    {
        for (int i = 1; i < m; i++)
        {
            iter++;
            if (iter == st.end())
                iter = st.begin();
        }
        iter = st.erase(iter);
        if (iter == st.end())
            iter = st.begin();
    }

    return st.back();;
}

安静的自己构造的循环单链表：

int ysf(int n, int m) {
        ListNode *p=new ListNode(1);
        ListNode *q=p;
        for(int i=2;i<=n;++i)
        {
            ListNode *r = new ListNode(i);
            q->next=r;
            q=r;
        }
        q->next=p;    //此时，构成环形链表
        while(p->next!=p)
        {
            for(int i=1;i<m;++i)
            {
                q=p;            //单链表，需要记录前一个结点
                p=p->next;
            }
            q->next=p->next;    //删除结点
            p=q->next;
        }
        return p->val;
    }