小编Sta*_*123的帖子

在学习 Fenwick Trees 时，我发现了这个实现：

来源：https : //algorithmist.com/wiki/Fenwick_tree

class Fenwick_Tree_Sum
{
    vector<int> tree;
    Fenwick_Tree_Sum(const vector<int>& Arg)//Arg is our array on which we are going to work
    {
        tree.resize(Arg.size());
        
        for(int i = 0 ; i<tree.size(); i++)
            increase(i, Arg[i]);
        
    }

    // Increases value of i-th element by ''delta''.
    void increase(int i, int delta)
    {
        for (; i < (int)tree.size(); i |= i + 1)
            tree[i] += delta;
    }

    // Returns sum of elements with indexes left..right, inclusive; (zero-based);
    int getsum(int left, int …

我正在使用 Visual C++，如果我编译这段代码：

class A {};
class B : private A {};
class C : public B
{
    void func()
    {
        A a{};
    }
};

我收到此错误：

错误 C2247：“A”不可访问，因为“B”使用“私有”从“A”继承

我知道如果我使用私有继承，那么类 'A' 的成员在 'B' 中将是私有的，在 'C' 中不可访问，但是为什么我不能在 'C' 中创建一个 'A' 的对象?

来自 GoF 的书：

原型对于像 C++ 这样的静态语言特别有用，其中类不是对象，并且在运行时很少或没有类型信息可用。在像 Smalltalk 或 Objective C 这样的语言中，它提供相当于原型（即类对象）以创建每个类的实例的内容并不重要。这种模式内置于基于原型的语言中，如 Self [US87]，其中所有对象的创建都是通过克隆原型进行的。

“类不是对象”是什么意思？

不总是这样吗？

一个类是一个对象是什么意思？

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
    int pid = fork();
    
    if (pid) {
        sleep(5);
        // wait(NULL); // works fine when waited for it.
    } else {
        execlp("vim", "vim", (char *)NULL);
    }
}

当我运行这段代码时，vim 运行正常，然后在 5 秒后崩溃（即当它的父退出时）。当我等待它（即不让它成为孤儿进程）时，代码完全正常。

为什么成为孤儿进程在这里成为一个问题？它是vim特有的吗？

为什么这甚至是 vim 可见的东西？我认为只有父母知道它的孩子什么时候死。但是在这里，我看到不知何故，孩子会注意到当它被收养时，会发生一些事情并以某种方式崩溃。当他们的父进程也死亡时，子进程会得到通知吗？

当我运行这段代码时，我在崩溃后得到这个输出：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
    int pid = fork();
    
    if (pid) {
        sleep(5);
        // wait(NULL); // works fine when waited for it.
    } else {
        execlp("vim", "vim", (char …

我刚刚了解了装饰器模式，并尝试编写一个使用该代码的示例。这个例子是关于饮料和一些调味品的。在装饰器内部，我有一个饮料的引用变量。可用的饮料是Decaf和Espresso。可用的调味品是Soy和Caramel。例如，如果我Decaf用多个来定义 a ，Caramel我得到的结果只是一个带有一个装饰器的 Decaf。所以定义Caramel-> Caramel->Decaf给我Caramel-> Decaf。定义Caramel-> Soy-> Caramel->Decaf工作正常。定义Caramel-> Soy-> Caramel-> Caramel->Decaf给我Caramel-> Soy-> Caramel->Decaf. 长话短说，我不能一个接一个地吃两种或多种相同类型的调味品。它们只成为一种调味品。如果我使用指针它工作正常。

编码：

#include <iostream>
//#include "Decaf.h"
//#include "Espresso.h"
//#include "SoyDecorator.h"
//#include "CaramelDecorator.h"

class Beverage
{
public:

    virtual std::string GetDescription() const = 0;
    virtual int GetCost() const …

class HeavyweightObjcet
{
    public void operate() {
        System.out.println("Operating...");
    }
}

class LazyInitializer
{
    HeavyweightObjcet objcet;

    public void operate()
    {
        if (objcet == null)
            objcet = new HeavyweightObjcet();
        objcet.operate();
    }
}

Here I'm making a virtual proxy for a heavyweight object. Each time before calling HeavyweightObject::operate, the program checks first whether the object is null or not. This part is checked once and only once through the entire lifetime of the object.

A possible improvement maybe using the state pattern …

我正在学习结构填充，并了解到结构填充背后的原因是，如果结构的成员未对齐，处理器将无法仅在一个周期内读取/写入它们。一般来说，由N字节组成的数据类型的位置应该是 的倍数的地址N。

假设这个结构体例如：

struct X
{
    char c;
    // 3 bytes padding here so that i is aligned.
    int i;
};

这里这个结构体的大小应该是8个字节，c默认是对齐的，因为它只占用1个字节，但i事实并非如此。对于i，我们需要在其前面添加 3 个字节的填充，使其“对齐”并且只能在一个周期内访问。告诉我我是否遗漏了什么。

1 - 对齐是如何工作的？成员们的立场是什么？

2 - 对于 CPU 访问N位于 的倍数地址的字节数据类型，什么更好N？例如，在上面的结构体中，如果i位于地址XXX3（以 3 结尾，换句话说，不是 4 的倍数），为什么不读取从地址开始的单词XXX3？为什么一定是4的倍数？大多数 CPU 访问的地址是否仅为字大小的倍数？我相信 CPU 可以从内存中的任意字节开始读取一个字。我错了吗？

3 - 为什么编译器不重新排序成员以便占用尽可能多的空间？顺序重要吗？我不确定是否有人使用实际的偏移量来访问成员。这意味着如果有一个 struct X x，通常会像这样访问成员：x.inot *(&x + 4)。在后一种情况下，顺序实际上很重要，但在第一种情况下（我相信每个人都使用），顺序不重要。我必须注意，在这个例子中，这并不重要，因为如果也i出现在前面c，那么末尾会有 3 个字节的填充。我一般都问为什么？ …

我有一个简单的类叫做SomeClass：

public class SomeClass {

    public int value = 0;

    public void inc() {
        value++;
    }

    public void dec()
    {
        if (isBiggerThanFive()) value--;
        value--;
    }

    private boolean isBiggerThanFive() {
        return value > 5;
    }
}

和一个名为的测试类TheTest：

class TheTest {

    SomeClass t;

    @BeforeEach
    void setUp() {
        t = new SomeClass();
    }

    @Test
    public void whenNewTestIsCreated_ValueIsZero()
    {
        assertEquals(t.value, 0);
    }

    @Test
    public void whenIncIsCalledWithValueOfZero_ValueIsOne()
    {
        t.inc();
        assertEquals(t.value, 1);
    }

    @Test
    public void whenDecIsCalledWithValueOfZero_ValueIsNegativeOne()
    {
        t.dec();
        assertEquals(t.value, -1);
    } …

在这里，在这个问题中，声明realloc在 C++ 中没有类似运算符或函数。如果您想调整数组的大小，只需std::vector改为。我什至看到 Stroustrup 在这里说同样的话。

我相信实现一个并不难。应该有一个不实施的理由。答案只说要使用，std::vector但没有说为什么没有实施。

不实现realloc-like 运算符或函数而宁愿使用的原因是什么std::vector？

#include <iostream>

struct X
{
    bool isNull() { return this == nullptr; }
    bool isNullConst() const { return this == nullptr; }
};

bool isNull(X& x) { return &x == nullptr; }
bool isNullConst(const X& x) { return &x == nullptr; }

// always false or exception.
bool isNullCopy(X x) { return &x == nullptr; } 

int main()
{
    X* x = nullptr;
    std::cout << x->isNull() << '\n';
    std::cout << (*x).isNull() << '\n';
    std::cout << isNull(*x) << '\n';
    // std::cout …