小编nit*_*ian的帖子

我在C++ : The Complete Reference书中读到以下内容

即使通过普通的按值调用参数传递机制将对象传递给函数,理论上它们可以保护和隔离调用参数,但是仍然可能发生可能影响甚至损坏的副作用,用作参数的对象.例如,如果用作参数的对象分配内存并在销毁时释放该内存,那么在调用析构函数时,函数内部的本地副本将释放相同的内存.这将使原始物体损坏并且实际上无用.

我真的不明白副作用是如何发生的.有人能通过一个例子来帮助我理解这一点吗？

我相信,一个derived class可以override只对那些从继承的功能base class.我的理解是否正确？

也就是说,如果基类具有公共成员函数func,那么派生类可以override是成员函数func.

但是如果基类有私有成员函数说foo,那么派生类不能覆盖成员函数foo.

我对吗？

编辑

在研究了SO成员给出的答案后,我想出了一个代码示例.我提到我在代码中作为评论研究的要点.希望我是对的.谢谢

/* Points to ponder:
   1. Irrespective of the access specifier, the member functions can be override in base class.
      But we cannot directly access the overriden function. It has to be invoked using a public
      member function of base class.
   2. A base class pointer holding the derived class obj's address can access only those members …

请考虑以下示例代码:

#include <iostream>

using namespace std;

class base
{
   public:
      base()
      {
         cout << "ctor in base class\n";
      }
};

class derived1 : public base
{
   public:
      derived1()
      {
         cout <<"ctor in derived1 class\n";
      }
};

class derived2 : public derived1
{
   public:
      derived2() : base()
      {
         cout << "ctor in derived2 class\n";
      }
};

int main()
{
   derived2 d2obj;
   return 0;
}

这给出了错误:

错误:类型`base'不是`derived2'的直接基础

为什么会出现此错误？如果我将基类设为虚拟,则错误不再存在.这是什么原因？

当我从基础构造函数调用虚函数时,编译器不会给出任何错误.但是当我从基类构造函数调用纯虚函数时,它会产生编译错误.

考虑下面的示例程序:

#include <iostream>

using namespace std;
class base
{
   public:
      void virtual virtualfunc() = 0;
      //void virtual virtualfunc();
      base()
      {
         virtualfunc();
      }
};

void base::virtualfunc()
{
   cout << " pvf in base class\n";
}

class derived : public base
{
   public:
   void virtualfunc()
   {
      cout << "vf in derived class\n";
   }
};

int main()
{
   derived d;
   base *bptr = &d;
   bptr->virtualfunc();

   return 0;
}

这里可以看出纯虚函数有一个定义.我期望在bptr->virtualfunc()执行时调用基类中定义的纯虚函数.相反,它给出了编译错误:

错误:从构造函数调用的抽象虚拟`virtual void base :: virtualfunc()'

这是什么原因？

请考虑以下示例代码:

#include <iostream>

using namespace std;

class base
{
   public:
      base()
      {
         bar(); //Line1
         this->bar(); //Line2
         base *bptr = this; 
         bptr->bar(); //Line3
         ((base*)(this))->bar(); //Line4
      }

      virtual void bar() = 0;
};

class derived: base
{
   public:
      void bar()
      {
         cout << "vfunc in derived class\n";
      }
};

int main()
{
   derived d;
}

上面的代码bar()在基类中具有纯虚函数,在派生类中被覆盖.纯虚函数bar()在基类中没有定义.

现在专注于Line1,Line2,Line3和Line4.

我理解:Line1给出编译错误,因为无法从ctor调用纯虚函数.

问题:

1. 为什么Line2并Line4没有给出compilation error在同样的理由 …

在我的剧本中，使用include_vars模块包含了一个 JSON 文件。JSON 文件的内容如下：

{
  "Component1": {
    "parameter1" : "value1",
    "parameter2" : "value2"
  },

  "Component2": {
    "parameter1" : "{{ NET_SEG_VLAN }}",
    "parameter2": "value2"       
  }
}

将 JSON 文件包含在剧本中后，我正在使用uri模块发送 http 请求，如下所示：

- name: Configure Component2 variables using REST API
  uri:
      url: "http://0.0.0.0:5000/vse/api/v1.0/config/working/Component2/configvars/"
      method: POST
      return_content: yes
      HEADER_x-auth-token: "{{ login_resp.json.token }}"
      HEADER_Content-Type: "application/json"
      body:  "{{ Component2 }}"
      body_format: json

可以看出，http 请求的正文与 JSON 数据一起发送Component2。但是，Jinja2 尝试替换{{ NET_SEG_VLAN }}JSON 文件中的 并抛出undefined错误。目的不是使用 Jinja2 替换 JSON 文件中的任何内容，而是像在 …

在 Django 中实现了自定义用户模型，并允许用户使用 URL http://127.0.0.1:8000/users/signup/进行注册。对此 url 的 GET 请求显示如下：

我已经为此页面编写了测试。测试是否get按预期工作。

我编写测试的post目的是让帖子在测试数据库中创建一个用户。之后我可以编写测试来确认是否创建了用户以及用户名是否匹配等等。但似乎用户没有被创建。以下是我的测试

class SignUpPageTests(TestCase):
    def setUp(self) -> None:
        self.username = 'testuser'
        self.email = 'testuser@email.com'
        self.age = 20
        self.password = 'password'

    def test_signup_page_url(self):
        response = self.client.get("/users/signup/")
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, template_name='signup.html')

    def test_signup_page_view_name(self):
        response = self.client.get(reverse('signup'))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, template_name='signup.html')

    def test_signup_form(self):
        response = self.client.post(reverse('signup'), data={
            'username': self.username,
            'email': self.email,
            'age': self.age,
            'password1': self.password,
            'password2': self.password
        })
        self.assertEqual(response.status_code, 200)

        users = get_user_model().objects.all()
        self.assertEqual(users.count(), 1)

users.count() 结果是 0，我的测试失败了。我哪里错了？

我正在研究Linux中的启动过程.我遇到这句话"RAM比软盘快几个数量级,所以系统操作从ramdisk快速"

无论如何,内核将在RAM中加载根文件系统以执行它.所以我的问题是,如果内核将根文件系统加载到RAM中,为什么我们需要一个ramdisk来加载根文件系统？

如果代码中有类似的内容:

func(const base& obj)

const语义是什么意思？这里有什么不变的？是obj a const reference to a non-const object还是a non-const reference to a const object？

可能重复：
未初始化的常量

我知道需要初始化 const 对象。

所以对于下面的代码，

class sample
{};

int main()
{
   const sample obj;
   return 0;
}

编译器会抱怨，因为 const 对象obj没有初始化。

但是当我使用默认构造函数修改代码（如下所示）时，编译器不会抛出任何错误。

class sample
{
    public:
       sample() { }
};

int main()
{
    const sample obj;
    return 0;
}

新添加的默认ctor做了哪些让编译器满意的事情？