24个基本的c++面试问题 *

类和结构之间的唯一区别是访问修饰符. Struct members are public by default; class members are private. It is good practice to use classes when you need an object that has methods and structs when you have a simple data object.

The answer is not -25. 相反，假设32位整数，答案(这将使许多人感到惊讶)是4294967271. Why?

In C++, 如果两个操作数的类型不同, then the operand with the “lower type” will be promoted to the type of the “higher type” operand, using the following type hierarchy (listed here from highest type to lowest type): long double, double, float, 无符号长整型, long int, unsigned int, int (lowest).

所以当两个操作数是，就像我们的例子一样， 25u (unsigned int)和 50 (int), the 50 被提升为一个无符号整数(i.e., 50u).

此外，操作的结果将是操作数的类型. 因此，结果 25u - 50u 它本身也是一个无符号整数吗. 所以结果是 -25 当提升为无符号整数时转换为4294967271.

最后一个参数 memset should be sizeof(*bar), not sizeof(bar). sizeof(bar) 的大小。 bar (i.e., the pointer itself)而不是指结构的大小 bar.

因此，代码可以通过使用 sizeof(*bar) 作为调用的最后一个参数 memset.

一个犀利的候选人可能会指出使用 *bar 是否会导致解引用错误 bar 还没有分配. 因此，更安全的解决方案是使用 sizeof (my_struct_t). 然而，一个更敏锐的候选人必须知道在这种情况下使用 *bar 在通话范围内是否绝对安全 sizeof, even if bar 还没有初始化，因为 sizeof 是编译时构造吗.

以上代码执行后， i 等于6，但是 j will equal 5.

Understanding the reason for this is fundamental to understanding how the unary increment (++)及减量(--)操作符在c++中工作.

当这些运算符 precede 一个变量，变量的值首先被修改和 then 使用修改后的值. 例如，如果我们将上面的代码片段修改为 int j = ++i;, i 会增加到6和 then j 会被设置为修改后的值，所以两者最终都等于6.

然而，当这些操作符 follow 一个变量，该变量的未修改值被使用和 then 它是递增的或递减的. 这就是为什么，在声明中 int j = i++; 在上面的代码片段中， j 第一个设置为未修改的值 i (i.e., 5) and then i 加到6.

上面代码中的问题是 --sz >= 0 will always 要真实，这样你就永远不会离开 while loop (so you’ll probably end up corrupting memory or causing some sort of memory violation or having some other program failure, 取决于你在循环中做什么).

原因是 --sz >= 0 will always 真正的是那种 sz is size_t. size_t 只是一种基本无符号整数类型的别名吗. 因此,自 sz 是无符号的，可以吗 never 小于零(因此条件永远不可能为真).

One example of an alternative implementation that would avoid this problem would be to instead use a for 循环如下:

for (size_t i = 0; i < sz; i++)
{
	/*做某事*/
}

尽管这两种选择将完成完全相同的事情, 从性能的角度来看，第二个选项更好. 这是因为自增后操作符(i.e., itr++)比预增量运算符(i.e., ++itr). The underlying implementation of the post-increment operator makes a copy of the element before incrementing it and then returns the copy.

That said, many compilers will automatically optimize the first option by converting it into the second.

这个问题测试你对c++模板的理解. An experienced developer will know that this is already a part of the C++11 std library (std::is_base_of)或c++ boost库的一部分(boost:: is_base_of). Even an interviewee with only passing knowledge should write something similar to this, 最有可能涉及到一个助手类:

template
类IsDerivedFromHelper
{
    class No { };
    class Yes { No no[3]; };
    
    静态是测试(B*);
    static No Test( ... );
public:
    enum { Is = sizeof(Test(static_cast(0))) == sizeof(Yes) };
    
};


template  
bool IsDerivedFrom() {
    return IsDerivedFromHelper::Is;
}

template 
struct is_same
{
    静态常量bool值= false;
};

template 
struct is_same
{
    静态常量bool值= true;
};


template 
bool IsSameClass() {
    return is_same::value;
}

尽管您可以从内联函数内部调用它, the compiler may not generate inline code since the compiler cannot determine the depth of recursion at compile time. A compiler with a good optimizer can inline recursive calls till some depth fixed at compile-time (say three or five recursive calls), and insert non-recursive calls at compile time for cases when the actual depth gets exceeded at run time.

此程序将异常终止. throw 32 会开始展开堆栈并销毁A类吗. 类A析构函数将在异常处理期间抛出另一个异常, 哪个会导致程序崩溃. 这个问题是测试开发人员是否有处理异常的经验.

创建另一个类，其中Something的所有成员的顺序相同, 但是有额外的返回值的公共方法. 你的副本Something类应该是这样的:

类SomethingReplica {
public:
    int getTopSecretValue() { return topSecretValue; }
    bool somePublicBool;
    int somePublicInt;
    std:: string somePublicString;
private:
    int topSecretValue;
};

Int main(Int argc, const char * argv[]) {
    Something a;
    SomethingReplica* b = reinterpret_cast(&a);
    std::cout << b->getTopSecretValue();
}

This problem seems easy at first glance so a careless developer might write something like this:

void F(int* A, int* B, int N) {
    int m = 1;
    for (int i = 0; i < N; ++i) {
        m *= A[i];
    }
    
    for (int i = 0; i < N; ++i) {
        B[i] = m / A[i];
    }
}

void F(int* A, int* B, int N) {
    //设置prod为中性的乘法元素
    int prod = 1;
    
    for (int i = 0; i < N; ++i) {
        //对于元素“i”，将B[i]设置为A[0] * ... * A[i - 1]
        B[i] = prod;
        //与A[i]相乘，将prod设置为A[0] * ... * A[i]
        prod *= A[i];
    }
    
    //重置prod并将其用于正确的元素
    prod = 1;
    
    for (int i = N - 1; i >= 0; --i) {
        //对于元素“i”，将B[i]乘以A[i + 1] * ... * A[N - 1]
        B[i] *= prod;
        //与A[i]相乘，设置prod为A[i] * ... * A[N - 1]
        prod *= A[i];
    }
}

While it’s ideal to avoid virtual inheritance altogether (you should know how your class is going to be used) having a solid understanding of how virtual inheritance works is still important:

#include 

class D {
public:
    void foo() {
        std::cout << "Foooooo" << std::endl;
    }
};


类C: public D {
};

类B: public D {
};

类A: public B, public C {
};

Int main(Int argc, const char * argv[]) {
    A a;
    a.foo();
}

类C:虚拟公共D {
};

类B:虚拟public D {
};

上面的命令将输出8，因为:

上面的命令将输出:

from A
from A
from Base

如果你说300，你 would 是正确的 i 已被宣布为 int. However, since i 被宣布为 unsigned char，正确答案是 这段代码将导致无限循环.

Implement foo(int, int)…

Void foo(int a, int b) {
// whatever
}

template  void foo(T1 a, T2 b) = delete;

template  
void f(T arg1, U arg2);

template <>
Void f(int arg1, int arg2)
{
    //...    
}

该行为未定义，因为 A的析构函数不是虚函数. From the spec:

A class that specifies the life and scope of its variables and functions is called a storage class.

Using an extern "C" declaration:

//C code
Void函数(int i)
{
//code
}

输出int(int i)
{
//code
}

//C++ code
extern "C"{
Void函数(int i);
Void print(int i);
}

Void myfunc(int i)
{
   func(i);
   print(i);
}

的实例 struct A 被视为整数值的数组. On 32-bit architectures the output will be 33, and on 64-bit architectures it will be 22. 这是因为存在虚方法 f() in the struct which makes compiler insert a vptr pointer that points to vtable (a table of pointers to virtual functions of class or struct). On 32-bit architectures the vptr takes 4 bytes of the struct instance and the rest is the data array, so arr[2] 表示对数据数组第二个元素的访问，该元素的值为33. 在64位体系结构中，vptr占用8字节 arr[2] 表示对数据数组第一个元素的访问，该数组包含22.

g++ question_vptr.CPP -m32 -std=c++
g++ question_vptr.cpp -std=c++11

A const member function is one which isn’t allowed to modify the members of the object for which it is called. A static 成员函数是指不能为特定对象调用的函数.

Void foo(int i);

obj.foo(10);

foo(&obj, 10);

void foo(T* const this, int i);

void foo(const * const this, int i);

The volatile keyword informs the compiler that a variable may change without the compiler knowing it. 变量声明为 volatile 不会被编译器缓存，因此总是从内存中读取.

It means that we cannot create hybrid inheritance using multiple and hierarchical inheritance.