面试总结之C/C++

source code

• https://github.com/haotang923/interview/blob/master/interview%20summary%20of%20C%20and%20CPP/

学习笔记之IKM C++ 11 - 浩然119 - 博客园

• https://www.cnblogs.com/pegasus923/p/8465745.html

学习笔记之100 TOP Ikm C++ Online Test Questions - 浩然119 - 博客园

• https://www.cnblogs.com/pegasus923/p/8533582.html

面试总结之指针 - 浩然119 - 博客园

• https://www.cnblogs.com/pegasus923/p/5581823.html

---

C

C structure，数据结构里有inter,char,float时，数据的内存布局会是怎样

• 数据会以4位或是8位，16位等等方式对齐

为什么会有这种对齐

• 这是因为机器寻址就是按照这种方式进行的，这样可以一次而不是多次读取一定数据

C pointer,指向数据结构与指向char的指针有区别吗

• 它们正做+1运算时产生的位移不同

函数指针,什么是函数指针，有什么用处

• 函数指针是指向函数的指针，最大的用处是做回调函数，可以做接口函数，就像系统中断中的中断处理函数

设计一个函数，函数中有一段功能是对相关数据的结理，但具体的处理方式是不定的。

• 将不定的处理方式设定成一个外部传来函数指针。(可以设计成这样 func(int a,int b，某种函数指针) )

如何对消息实现同步响应

• 使用CALLBACK，回调函数
• CALLBACK_百度百科
  • https://baike.baidu.com/item/CALLBACK/813549?fr=aladdin

struct和union的区别：

1. 在存储多个成员信息时，编译器会自动给struct第个成员分配存储空间，struct可以存储多个成员信息，而union每个成员会用同一个存储空间，只能存储最后一个成员的信息。
2. 都是由多个不同的数据类型成员组成，但在任何同一时刻，Union只存放了一个被先选中的成员，而结构体的所有成员都存在。
3. 对于Union的不同成员赋值，将会对其他成员重写，原来成员的值就不存在了，而对于struct的不同成员赋值是互不影响的。

• http://blog.csdn.net/firefly_2002/article/details/7954458

struct和class的区别：

• Access Control and Constraints of Structures, Classes and Unions
  • https://msdn.microsoft.com/en-us/library/4a1hcx0y.aspx

Structures	Classes	Unions
class key is struct	class key is class	class key is union
Default access is public	Default access is private	Default access is public
No usage constraints	No usage constraints	Use only one member at a time
Default inheritance is public	Default inheritance is private	-
Could not use Template	Could use Template	-

static关键字至少有下列n个作用：

1. 函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
2. 在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
3. 在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
4. 在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
5. 在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

const关键字至少有下列n个作用：

1. 欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
2. 对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
3. 在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
4. 对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
5. 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。

#include “filename.h”和#include <filename.h>的区别

• #include “filename.h”是指编译器将从当前工作目录上开始查找此文件
• #include <filename.h>是指编译器将从标准库目录中开始查找此文件

用C语言，将一个数字乘以7倍的效率最快的方法是什么？ 

---

C++

变量的内存分区

• C/C++的四大内存分区 - CSDN博客
  • https://blog.csdn.net/K346K346/article/details/45592329

size_t_百度百科

• http://baike.baidu.com/link?url=sh8RRfasW1QG-PhcWPZhfcZ75Uw-KYLKh443jzpNg36hVk1Fu7WeTh4lEPLCuBx_iT0wglX5MRQUqXJMWV-oUK

什么是深浅拷贝?

• 浅拷贝是创建了一个对象用一个现成的对象初始化它的时候只是复制了成员(简单赋值)而没有拷贝分配给成员的资源(如给其指针变量成员分配了动态内存); 深拷贝是当一个对象创建时，如果分配了资源，就需要定义自己的拷贝构造函数，使之不但拷贝成员也拷贝分配给它的资源

短小而被频繁调用的程序如何处理？

• C语言用宏代替。
• C++用inline，内联函数机制。
• 内联函数可以得到宏的替换功能，所有可预见的状态和常规函数的类型检查。

指针和引用的初始化区别

• 引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
• 不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
• 一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

delete数组指针，只delete第一个后果

• 内存泄漏 

什么是拷贝构造函数?

• 它是单个参数的构造函数，其参数是与它同属一类的对象的(常)引用；类定义中，如果未提供自己的拷贝构造函数，C++提供一个默认拷贝构造函数，该默认拷贝构造函数完成一个成员到一个成员的拷贝

要在C++ 防止对象被复制，有什么方法

• 将复制构造函数变成私有函数

虚析构函数

• 虚析构函数_百度百科
  • https://baike.baidu.com/item/虚析构函数
  • 虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。
  • 如果某个类不包含虚函数，那一般是表示它将不作为一个基类来使用。当一个类不准备作为基类使用时，使析构函数为虚一般是个坏主意。因为它会为类增加一个虚函数表，使得对象的体积翻倍，还有可能降低其可移植性
  • 所以基本的一条是：无故的声明虚析构函数和永远不去声明一样是错误的。实际上，很多人这样总结：当且仅当类里包含至少一个虚函数的时候才去声明虚析构函数。抽象类是准备被用做基类的，基类必须要有一个虚析构函数，纯虚函数会产生抽象类，所以方法很简单：在想要成为抽象类的类里声明一个纯虚析构函数。

函数对象功能

• 可以用作类似C里的回调函数，也可以用作函数功能的组合

C++虚拟机制

• 用来实现多态

抽象类能被实例化吗

• 不能，只能继承抽象类，实现抽象类的函数

Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体。

C++如何实现JAVA接口

• java接口_百度百科
  • http://baike.baidu.com/link?url=hoPdmBnxPUNPpyCRPD80NQVbOPS0qT5IoI1jezWUDT4Dz0MdgaVrPEurjtacqy6rJRZxO0CrQCNqDn5czUriNK
• C++中的抽象类以及接口的区别联系_Linux编程_Linux公社-Linux系统门户网站
  • http://www.linuxidc.com/Linux/2012-10/73243.htm

Object Slicing

• Object slicing - Wikipedia
  • https://en.wikipedia.org/wiki/Object_slicing
  • In C++ programming, object slicing occurs when an object of a subclass type is copied to an object of superclass type: the superclass copy will not have any of the member variables defined in the subclass. These variables have, in effect, been "sliced off".) More subtly, object slicing can also occur when an object of a subclass type is copied to an object of the same type by the superclass's assignment operator, in which case some of the target object's member variables will retain their original values instead of being copied from the source object.
  • This issue is not inherently unique to C++, but it does not occur naturally in most other object-oriented languages — even C++'s relatives such as D, Java, and C# — because copying of objects is not a basic operation in those languages. (Instead, those languages prefer to manipulate objects via implicit references, such that only copying the reference is a basic operation.) In C++, by contrast, objects are copied automatically whenever a function takes an object argument by value or returns an object by value. Additionally, due to the lack of garbage collection in C++, programs will frequently copy an object whenever the ownership and lifetime of a single shared object would be unclear; for example, inserting an object into a standard-library collection, such as a std::vector, actually involves inserting a copy into the collection.
• c++对象切割 - CSDN博客
  • https://blog.csdn.net/weiwangchao_/article/details/4702241

异常,异常的功能

• 保证异常的健壮性，结构化处理出错信息

C++模板

• 简化对类似函数的设计，比如要设计两个函数 abs(int a), abs(float a),就可以用模板去设计一个函数就可以了

STL containers内部实现的数据结构

• vector ：数组
• list ：链表
• set / map / multimap / multiset ：红黑树
• unordered_set / unordered_multiset / unordered_map / unordered_multimap ：Hash表
• Containers - C++ Reference
  • http://www.cplusplus.com/reference/stl/
• STL实现的底层数据结构简介 - CSDN博客
  • http://blog.csdn.net/huangkq1989/article/details/7277282

list v.s. vector

智能指针

• 智能指针_百度百科
  • http://baike.baidu.com/link?url=-4Fxt6pJdzfT54y9W-fRgMxlSYiedMOkLOxNlQf67rz_wHTOhIvtESgw6s8sEdgGMy2PxyNj0VUNe_IpaSBnbK
  • 当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。
  • 智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。
  • 每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
  • 实现引用计数有两种经典策略：一是引入辅助类，二是使用句柄类。
  • 为了避免方案一中每个使用指针的类自己去控制引用计数，可以用一个类把指针封装起来。封装好后，这个类对象可以出现在用户类使用指针的任何地方，表现为一个指针的行为。我们可以像指针一样使用它，而不用担心普通成员指针所带来的问题，我们把这样的类叫句柄类。在封装句柄类时，需要申请一个动态分配的引用计数空间，指针与引用计数分开存储。
  • 智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。
  • 事实上，智能指针能够做的还有很多事情，例如处理线程安全，提供写时复制，确保协议，并且提供远程交互服务。有能够为这些ESP (Extremely Smart Pointers)创建一般智能指针的方法，但是并没有涵盖进来。
  • 智能指针的大部分使用是用于生存期控制，阶段控制。它们使用operator->和operator*来生成原始指针，这样智能指针看上去就像一个普通指针。
  • 这样的一个类来自标准库：std::auto_ptr。它是为解决资源所有权问题设计的，但是缺少对引用数和数组的支持。并且，std::auto_ptr在被复制的时候会传输所有权。在大多数情况下，你需要更多的和/或者是不同的功能。这时就需要加入smart_ptr类。
•  智能指针（现代 C++）
  • https://msdn.microsoft.com/zh-cn/library/hh279674.aspx
•  Smart pointer - Wikipedia, the free encyclopedia
  • https://en.wikipedia.org/wiki/Smart_pointer
•  智能指针：从std::auto_ptr到std::unique_ptr - hanhuili的专栏 - 博客频道 - CSDN.NET
  • http://blog.csdn.net/hanhuili/article/details/8299912

RAII

• RAII - 维基百科，自由的百科全书
  • https://zh.wikipedia.org/wiki/RAII
  • RAII全称为Resource Acquisition Is Initialization，它是在一些面向对象语言中的一种惯用法。RAII源于C++，在Java，C#，D，Ada，Vala和Rust中也有应用。1984-1989年期间，比雅尼·斯特劳斯特鲁普和安德鲁·柯尼希在设计C++异常时，为解决资源管理时的异常安全性而使用了该用法，后来比雅尼·斯特劳斯特鲁普将其称为RAII。
  • RAII要求，资源的有效期与持有资源的对象的生命期严格绑定，即由对象的构造函数完成资源的分配(获取)，同时由析构函数完成资源的释放。在这种要求下，只要对象能正确地析构，就不会出现资源泄露问题。
• RAII_百度百科
  • http://baike.baidu.com/link?url=cZ_EqWVrbxk9AIOFJ-9IrYDMRVaeEtubQlI-JKvquwrTkm9clZshXDLN9WM1Kth0W98ADgTckgMMEAwmQ3gZDq
  • RAII，也称为“资源获取就是初始化”，是c++等编程语言常用的管理资源、避免内存泄露的方法。它保证在任何情况下，使用对象时先构造对象，最后析构对象。
• 对象所有资源 (RAII)
  • https://msdn.microsoft.com/zh-cn/library/hh438480.aspx

RTTI

• RTTI事指运行时类型识别（Run-time type identification）在只有一个指向基类的指针或引用时确定一个对象的准确类型。

volatile

• volatile_百度百科
  • 　　http://baike.baidu.com/link?url=gPm-SmXKapujjcPjO3COGYDPSvH4VPOMabuV61XG7kM1kMhwX1AnNxF5_VZDiq7fizEaEfpYKLRBVgRt99BxOK
• volatile (C++)
  • 　　https://msdn.microsoft.com/zh-cn/library/12a04hfd.aspx

你们要的C++面试题答案来了--基础篇

• https://mp.weixin.qq.com/s/-Yo1m5bwe1bHkXuAjV17gQ
• https://www.nowcoder.com/tutorial/93/a34ed23d58b84da3a707c70371f59c21

---

PROGRAMMING

What will be printed, and why?

class A
{
public:
    A () : data (0) { SetData (); printf ("data=%d", data); }
    virtual void SetData () { data = 1; }
protected:
    int data;
};

class B : public A
{
public:
    B () {}
    virtual void SetData () { data = 2; }
};

int main(int argc, char* argv[])
{
    B b;
    return 0;
}

• data=1.
• Because class B inherits class A, it would call constructor of A and B when constructing b. When calling the constructor of A, A::SetData() was called, so data was set to 1.

What's wrong, and how to fix?

class TryConst
{
public:
    TryConst () {}
private:
    const int aaa;
};

• Const variable aaa should be initialized when being defined.
• To fix it, we could take any one action as below.
  • 1) Initialize aaa in construct function
  • 2) Assign a value in this statement const int aaa;
  • 3) Remove keyword const

What's wrong, and how to fix?

class TryStatic
{
public:
    TryStatic () : aa (0) {}
private:
    static int aa;
};

• Static variable could not be initialized inside the class.
• To fix it, we could initialize it outside the class, e.g. int aa = 0. 

What will be printed, and why?

class TestSize1
{
public:
    TestSize1 () : a (0) {}
    virtual void F () = 0;
private:
    int a;
};
class TestSize2 : public TestSize1
{
public:
    TestSize2 () : b (1) {}
    virtual void F () { b = 3; }
private:
    int b;
};
int main(int argc, char* argv[])
{
    printf ("size of TestSize2 = %d", sizeof (TestSize2));
    return 0;
}

• In 32-bit environment, size of TestSize2 = 12.
• 12 = TestSize2 virtual table pointer(4) + TestSize2::b(4) + TestSize1::a(4)

What's wrong, and how to fix?

class P1
{
public:
    P1 () { p = new char [10]; }
    ~P1 () { delete [] p; }
private:
    char * p;
};
class P2 : public P1
{
public:
    P2 () { q = new char [20]; }
    ~P2 () { delete [] q; }
private:
    char * q;
};

int main(int argc, char* argv[])
{
    P1 * pp = new P2;
    ...
    delete pp;
    return 0;
}

• ~P2 would not be executed, which would cause memory leak.
• To fix it, define ~P1() as virtual ~P1().

What's wrong, and how to fix?

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//
#include <iostream>
using namespace std;

class Thing {
public:
    void    doSomething() { cout << __func__ << endl; }
    Thing*    next;
};

class Things {
public:
    Things(Thing *myThing) : head(myThing), current(myThing) {}
    
    Thing*  First() {
        return head;
    }
    
    Thing*  Next() {
        current = current->next;
        return current;
    }
    
    bool OK() {
        if (current != nullptr)
            return true;
        else
            return false;
    }
    
private:
    Thing *head, *current;
};

int main()
{
    Thing*   myThing = new Thing;
    Things myThings(myThing);
    
    // This is how we do with class Things
    /*
     doSomething
     */
    for (Thing *ptr = myThings.First(); myThings.OK(); myThings.Next()) {
        ptr->doSomething();
    }
    
    return 0;
}

• When multiple access, the Next function will make the current pointer behave unexpected. E.g. A is calling doSomething(), and B issues Next(). When A issues Next(), actually the current node is not current->next but current->next->next.
• To fix it, add a parameter for Next() => Next(Thing *currentNode) so that it could make sure that the next node would not be changed by others.

strcpy,使用strcpy需注意什么，为什么，有什么更安全的函数

• 注意源字符串是是以‘'结束的，strcpy就是拷到源字符串中‘'才结束，可能使用strncpy来替换。
• assert（编程术语）_百度百科（https://baike.baidu.com/item/assert/10931289?fr=aladdin#4）

#include <assert.h>

//    为了实现链式操作，将目的地址返回
char * strcpy(char *strDest, const char *strSrc)
{
    // 对原地址和目的地址加非0断言
    assert(strDest != NULL && strSrc != NULL);

    char *address = strDest;
    
    while ((*strDest++ = *strSrc++) != '');
    
    return address;
}

strlen

#include <assert.h>

// 入参const
int strlen(const char *str)
{
    // 断言字符串地址非0
    assert(str != NULL);
    
    int len = 0;
    
    while ((*str++) != '') len ++;
    
    return len;
}

struct数组定义和初始化，以及for循环第一次循环会执行哪些语句，比较tricky，注意i--语句执行先后顺序。

//
//  main.c
//  LeetCode
//
//  Created by Hao on 2017/11/22.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <stdio.h>

// Calculate the number of elements in x
#define myMacro(x) sizeof((x)) / sizeof((x[0]))

// Definition and initialization of array of struct
struct structTest {
    int   digit;
    char *number;
} strTest[] = { {1, "one"},     {2, "two"},
                {3, "three"},   {4, "four"},
                {5, "five"},    {6, "six"},
                {7, "seven"},   {8, "eight"},
                {9, "nine"},    {10, "ten"} };

int getNumber1(char *number)
{
    int i;
    
    printf("Before for-loop : i = %d

", i);

    for (i = myMacro(strTest); i --;) // i -- will be executed at the BEGINNING of the first loop
    {
        printf("Loop i = %d
", i);
        printf("[%d : %s]
", strTest[i].digit, strTest[i].number);
        if (strcmp(strTest[i].number, number)) // return value 0 only if the contents of both strings are equal
        {
            printf("Before continue : %d
", i);
            continue;
        }
        printf("Before break : %d
", i);
        break;
    }
    
    printf("
After for-loop : %d

", i);
    return i;
}

int getNumber2(char *number)
{
    int i;
    
    printf("Before for-loop : i = %d

", i);
    
    for (i = myMacro(strTest); ; i --) // i -- will be executed at the END of the first loop
    {
        printf("Loop i = %d
", i);
        printf("[%d : %s]
", strTest[i].digit, strTest[i].number);
        if (strcmp(strTest[i].number, number))
        {
            printf("Before continue : %d
", i);
            continue;
        }
        printf("Before break : %d
", i);
        break;
    }
    
    printf("
After for-loop : %d

", i);
    return i;
}

int main()
{
    printf("myMacro(strTest) = %d

", myMacro(strTest));
    
    printf("getNumber1("zero") = %d

", getNumber1("zero"));

    printf("getNumber1("nine") = %d

", getNumber1("nine"));
    
    printf("getNumber2("zero") = %d

", getNumber2("zero"));
    
    printf("getNumber2("nine") = %d

", getNumber2("nine"));
    
    return 0;
}

• 执行结果可以看到getNumber1的第一次循环开始时已经执行i--，而getNumber2并没有，原因就在于i--位于不同位置。

myMacro(strTest) = 10

Before for-loop : i = 0

Loop i = 9
[10 : ten]
Before continue : 9
Loop i = 8
[9 : nine]
Before continue : 8
Loop i = 7
[8 : eight]
Before continue : 7
Loop i = 6
[7 : seven]
Before continue : 6
Loop i = 5
[6 : six]
Before continue : 5
Loop i = 4
[5 : five]
Before continue : 4
Loop i = 3
[4 : four]
Before continue : 3
Loop i = 2
[3 : three]
Before continue : 2
Loop i = 1
[2 : two]
Before continue : 1
Loop i = 0
[1 : one]
Before continue : 0

After for-loop : -1

getNumber1("zero") = -1

Before for-loop : i = 0

Loop i = 9
[10 : ten]
Before continue : 9
Loop i = 8
[9 : nine]
Before break : 8

After for-loop : 8

getNumber1("nine") = 8

Before for-loop : i = 0

Loop i = 10
[0 : (null)]
(lldb)

编写类String的构造函数、析构函数、拷贝构造函数和赋值函数。

• 类String的构造函数、析构函数和赋值函数 - dazhong159的专栏 - CSDN博客（http://blog.csdn.net/dazhong159/article/details/7894384）
• 输入输出运算符必须是普通非成员函数，而不能是类的成员函数。否则，它们的左侧运算对象将是我们的类的一个对象。假设输入输出运算符是某个类的成员，则它们也必须是istream或ostream的成员。然而，这两个类属于标准库，并且我们无法给标准库中的类添加任何成员。当然，IO运算符通常需要读写类的非公有数据成员，所以IO运算符一般被声明为友元。
• 注意delete释放资源之前，最好先判断是否nullptf，否则释放为nullptr的指针会报错。此处拷贝构造与赋值函数中，因为m_data不会为nullptr，所以可以不判断。

#include <iostream>
#include <string>
using namespace std;

class String {
public :
    String (const char *str = NULL); // default initial value
    String (const String &other);
    ~ String (void);
    String & operator=(const String &other);
    friend ostream &operator<<(ostream &os, const String &str);
    friend istream &operator>>(istream &is, String &str);
private :
    char *m_data;
};

// 普通构造函数
String::String(const char *str)
{
    if (str == NULL) { // empty string
        m_data = new char[1];
        *m_data = '';
    } else {
        int length = strlen(str);
        m_data = new char[length + 1];
        strcpy(m_data, str);
    }
}

// 析构函数
String::~String(void)
{
    delete[] m_data;
}

// 拷贝构造函数
String::String(const String &other)
{
    int length = strlen(other.m_data);
    m_data = new char[length + 1];
    strcpy(m_data, other.m_data);
}

// 赋值函数
String & String::String::operator=(const String &other)
{
    // 检查自赋值
    if (this == &other)
        return *this;
    
    // 释放原有的内存资源
    delete[] m_data;

    int length = strlen(other.m_data);
    m_data = new char[length + 1];
    strcpy(m_data, other.m_data);

    return *this;
}

ostream &operator<<(ostream &os, const String &str)
{
    os << str.m_data;
    
    return os;
}

istream &operator>>(istream &is, String &str)
{
    char *sTemp = new char[1000];
    
    is >> sTemp;
    
    // Must check if input succeeds
    if (is) {
        delete[] str.m_data;
        
        int length = strlen(sTemp);
        str.m_data = new char[length + 1];
        strcpy(str.m_data, sTemp);
    } else
        str = String(); // if fail, set to the default value
    
    delete[] sTemp;
    
    return is;
}

int main()
{
    String s1;
    String s2("Test");
    String s3 = s2;
    
    cout << s1 << endl;

    s1 = s2;
    
    cout << s1 << endl;
    
    cin >> s1;
    
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
    
    return 0;
}

删除字符串的首尾多余空格

• 利用STL方法，记得处理string::npos。
• 注意对空格字符串输入“ ”，输出仍是“ ”，只删除首尾多余空格。
• string::find_first_not_of - C++ Reference
  • http://www.cplusplus.com/reference/string/string/find_first_not_of/
• string::npos - C++ Reference
  • http://www.cplusplus.com/reference/string/string/npos/

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <iostream>
#include <string>
#include <cstddef>        // std::size_t
using namespace std;

class Solution
{
public:
    void TrimSpaces(string& ioStr)
    {
        size_t  startPos = ioStr.find_first_not_of(" ");
        size_t  endPos = ioStr.find_last_not_of(" ");
        
        cout << startPos << "
" << endPos << endl;

        // npos is a static member constant value with the greatest possible value for an element of type size_t.
        // This constant is defined with a value of -1, which because size_t is an unsigned integral type, it is the largest possible representable value for this type.
        if (startPos == string::npos)
            startPos = 0;
        if (endPos == string::npos)
            endPos = 0;
        
        cout << startPos << "
" << endPos << endl;
        
        ioStr = ioStr.substr(startPos, endPos - startPos + 1);
    }
};

int main ()
{
    Solution testSolution;

    string  str[5] = {"  abc     ", "abc     ", "    abc", " ", ""};
    
    for (auto i = 0; i < 5; i ++)
    {
        testSolution.TrimSpaces(str[i]);
        cout << """ << str[i] << """ << "
" << endl;
    }

    return 0;
}

• 执行结果注意string::npos的值。

4
4
"abc"
2
2
"abc"
6
6
"abc"
18446744073709551615
0
" "
18446744073709551615
0
""

Program ended with exit code: 0

输出Fibonacci数列的第N项

• 注意解法有递归，非递归和数学方法。
• 输入N最好用unsigned int类型。

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <iostream>
using namespace std;

class Solution
{
public:
    int Fibonacci(const int& n)
    {
        if (n == 0)
            return 0;
        else if (n == 1)
            return 1;
        else {
            int t, f0 = 0, f1 = 1;
            
            for (int i = 2; i < n + 1; i ++)
            {
                t = f1;
                f1 = f0 + f1;
                f0 = t;
            }
            
            return f1;
        }
    }
    
};

int main(int argc, char* argv[])
{
    Solution    testSolution;
    
    for (auto i = 0; i < 10; i ++)
        cout << testSolution.Fibonacci(i) << endl;
    
    return 0;
}

0
1
1
2
3
5
8
13
21
34
Program ended with exit code: 0

判断一个字符串是不是回文串

• 注意给出两种定义：一种是严格回文串，完美匹配；另一种只考虑数字字母，且大小写不敏感 
• LeetCode 125. Valid Palindrome
  • http://www.cnblogs.com/pegasus923/p/5612541.html
• toupper - C++ Reference
  • http://www.cplusplus.com/reference/cctype/toupper/
• isalnum - C++ Reference
• http://www.cplusplus.com/reference/cctype/isalnum/?kw=isalnum
• reverse - C++ Reference
  • http://www.cplusplus.com/reference/algorithm/reverse/

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <iostream>
#include <string>
#include <algorithm>    // reverse
#include <cctype>       // toupper, isalnum
using namespace std;

class Solution
{
public:
    // Reverse the whole string
    int isPalindrome(const string& str)
    {
        if (str.empty()) return false;
        
        string sTemp = str;
        
        cout << sTemp << endl;
        
        // STL algorithm
        reverse(sTemp.begin(), sTemp.end());
        
        cout << sTemp << endl;
        
        return (sTemp == str);
    }
    
    // Considering only alphanumeric characters and ignoring cases
    int isPalindrome2(const string& str)
    {
        if (str.empty()) return false;
        
        size_t start = 0, end = str.size() - 1;
        
        while (start < end)
        {
            if (! isalnum(str.at(start)))
                ++ start;
            else if (! isalnum(str.at(end)))
                -- end;
            else if (toupper(str.at(start)) != toupper(str.at(end)))
                return false;
            else {
                ++ start;
                -- end;
            }
        }
        
        return true;
    }
};

int main(int argc, char* argv[])
{
    Solution    testSolution;
    
    auto words = {"A man, a plan, a canal: Panama", "race a car", "", "a b a"};
    
    for (auto word : words)
        cout << testSolution.isPalindrome(word) << endl;

    cout << endl;
    
    for (auto word : words)
        cout << testSolution.isPalindrome2(word) << endl;

    return 0;
}

A man, a plan, a canal: Panama
amanaP :lanac a ,nalp a ,nam A
0
race a car
rac a ecar
0
0
a b a
a b a
1

1
0
0
1
Program ended with exit code: 0

 判断一个数是不是10的幂

• 细心，注意判断条件。

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <iostream>
using namespace std;

class Solution
{
public:
    bool isPowerOfTen(int n)
    {
        if (n < 1)
            return false;
        
        while (n % 10 == 0) {
            n /= 10;
        }
        
        return n == 1;
    }
};

int main(int argc, char* argv[])
{
    Solution    testSolution;
    
    int result = 1;
    
    result = result && testSolution.isPowerOfTen(1);
    result = result && testSolution.isPowerOfTen(10);
    result = result && testSolution.isPowerOfTen(10000000);
    result = result && !testSolution.isPowerOfTen(0);
    result = result && !testSolution.isPowerOfTen(-1);
    result = result && !testSolution.isPowerOfTen(110);

    if (result)
        cout << "ALl tests pass!" << endl;
    
    return 0;
}

找出最长重复字符子串

• 考察字符串基本功，从头到尾扫描一遍，注意判断字符指针结束符。

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <stdio.h>
#include <string.h>

typedef struct substr {
    int start, length;
} substr;

substr longest_uniform_substring(char * input)
{
    if (input == nullptr || strlen(input) == 0)
        return (substr){ -1, 0 };
    
    int st = 0, len = 1, resSt = 0, maxLen = 1, cur = 0;
    char cTemp = *input;

    ++ input;
    cur += 1;

    while (*input != '')  // pay attention to the terminator ''
    {
        if (*input == cTemp) {
            len += 1;
        } else {
            cTemp = *input;
            st = cur;
            len = 1;
        }
        
        if (len > maxLen) {
            resSt = st;
            maxLen = len;
        }
        
        ++ input;
        cur += 1;
    }
    
    return (substr){ resSt, maxLen };
}

int main(int argc, char* argv[])
{
    int result = 1;
    
    substr test = longest_uniform_substring("");
    result = result && (test.start == -1 && test.length == 0);

    test = longest_uniform_substring("10000111");
    result = result && (test.start == 1 && test.length == 4);

    test = longest_uniform_substring("aabbbbbCdAA");
    result = result && (test.start == 2 && test.length == 5);

    if (result)
        printf("ALl tests pass!
");
    
    return 0;
}

按照概率输出determined rate result 01，例如rate = 0.25，00010001。

• 概率题。累加概率到1则输出。注意对double跟1的比较要用精度控制。

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

class Rate {
public:
    Rate(double rate) : m_rate(rate), m_total(rate) {}  // inialization
    
    bool keep() {
//        cout << m_total << " ";

        if (m_total < 1 - 1e-10) {  // pay attention to the double precision control. Actually 1 is 0.999...9 in memory.
            m_total += m_rate;
            return false;
        } else {    // reset the rate
            m_total = m_total - 1 + m_rate;
            return true;
        }
    }

private:
    double m_rate, m_total;
};

int main()
{
    vector<Rate>    myRates{Rate(0.3), Rate(0.25)};
    
    /*
     0 0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 1
     0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
     */
    for (auto & myRate : myRates) {
        for (int i = 0; i < 20; i ++) {
            if (myRate.keep())
                cout << "1 ";
            else
                cout << "0 ";
        }
        cout << endl;
    }

    return 0;
}

Write a program that creates a standard deck of cards, shuffles them and returns the top card from the deck. (This is a standalone program, you are not passed in any data.)

• Fisher–Yates shuffle - Wikipedia
  • https://en.wikipedia.org/wiki/Fisher–Yates_shuffle
• 洗牌算法汇总以及测试洗牌程序的正确性 - tenos - 博客园
  • http://www.cnblogs.com/TenosDoIt/p/3384141.html　　

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> cards;
    int         n = 54;
    
    for (int i = 0; i < n; i ++) {
        cards.push_back(i + 1);
    }
    
    for (int i = n - 1; i > 0; i --) {
        int j = rand() % (i + 1);
        swap(cards[i], cards[j]);
    }
  
    // STL for reference
//    random_shuffle(cards.begin(), cards.end());
    
    /*
     13 10 15 43 9 22 33 5 3 52 36 35 51 49 46 34 41 24 23 48 32 50 16 2 44 7 53 40 30 11 42 54 8 4 18 17 19 12 27 28 47 1 45 29 20 26 38 25 21 31 39 6 37 14
     */
    for (auto card : cards) {
        cout << card << " ";
    }
    
    return 0;
}

---

2019 C++开发工程师面试题大合集

• https://mp.weixin.qq.com/s/-10JR6gIIOaTc6LDnCEeew