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

类和结构之间的唯一区别是访问修饰符. Struct members are public by default; class members are private. 当您需要一个具有方法和结构的对象时，当您有一个简单的数据对象时，使用类是一种很好的做法.

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

In C++, 如果两个操作数的类型不同, 然后，具有“低类型”的操作数将提升为“高类型”操作数的类型, 使用以下类型层次结构(此处从最高类型到最低类型列出), double, float, 无符号长整型, long int, unsigned int, int (lowest).

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

此外，操作的结果将是操作数的类型. 因此，结果 25u - 50u 它本身也是一个无符号整数吗. So the result of -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.

理解其中的原因是理解一元增量(++)及减量(--)操作符在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 循环，因此您可能最终会破坏内存或导致某种类型的内存冲突或出现其他一些程序故障, 取决于你在循环中做什么).

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

可以避免此问题的替代实现的一个示例是使用 for 循环如下:

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

尽管这两种选择将完成完全相同的事情, 从性能的角度来看，第二个选项更好. 这是因为自增后操作符(i.e., itr++)比预增量运算符(i.e., ++itr). 后自增操作符的底层实现在对元素进行自增之前先复制该元素，然后返回该副本.

That said, 许多编译器会自动优化第一个选项，将其转换为第二个选项.

这个问题测试你对c++模板的理解. 有经验的开发人员会知道这已经是c++ 11 std库(std::is_base_of)或c++ boost库的一部分(boost:: is_base_of). 即使是一个只有及格知识的受访者也应该写一些类似的东西, 最有可能涉及到一个助手类:

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;
}

尽管您可以从内联函数内部调用它, 编译器可能不会生成内联代码，因为编译器无法在编译时确定递归深度. 具有良好优化器的编译器可以内联递归调用，直到在编译时固定一定深度(例如三或五个递归调用)。, 并在编译时插入非递归调用，以防在运行时超出实际深度.

此程序将异常终止. 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();
}

乍一看，这个问题似乎很简单，所以粗心的开发人员可能会这样写:

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];
    }
}

虽然完全避免虚拟继承是理想的(你应该知道你的类将如何被使用)，但对虚拟继承的工作原理有一个坚实的理解仍然很重要:

#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:

指定其变量和函数的生命周期和作用域的类称为存储类.

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 被视为整数值的数组. 在32位体系结构上，输出将是33，在64位体系结构上，输出将是22. 这是因为存在虚方法 f() 在结构体中，使编译器插入一个指向虚表的VPTR指针(指向类或结构体的虚函数的指针表)。. 在32位体系结构上，vptr占用struct实例的4个字节，其余的是数据数组, 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 成员函数是不允许修改调用它的对象的成员的函数. 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 关键字通知编译器变量可能在编译器不知道的情况下发生变化. 变量声明为 volatile 不会被编译器缓存，因此总是从内存中读取.

这意味着我们不能使用多重继承和分层继承来创建混合继承.