c++ self 在初始化列表中

发布于 2024-11-07 14:04:02 字数 654 浏览 5 评论 0原文

我有这个代码片段

class Osoba{
         Osoba(char* imie,int wiek){                         
                     this->imie=new char[strlen(imie)+1];
                     strcpy(this->imie,imie);
                     this->wiek=wiek;
                     cout<<"Utworzono Osobe "<<this->imie<<endl;
         }
         Osoba(Osoba& x){
                 Osoba(x.imie,x.wiek);
         }
[...]

，当我调用复制构造函数时，它不起作用（创建和销毁对象）。

编辑：如果我使用

         Osoba(Osoba& x): Osoba(x.imie,x.wiek){

我得到类型'class Osoba'不是'Osoba'的直接基础

这是如何完成的？

原文

i have this code snippet

class Osoba{
         Osoba(char* imie,int wiek){                         
                     this->imie=new char[strlen(imie)+1];
                     strcpy(this->imie,imie);
                     this->wiek=wiek;
                     cout<<"Utworzono Osobe "<<this->imie<<endl;
         }
         Osoba(Osoba& x){
                 Osoba(x.imie,x.wiek);
         }
[...]

and when i call the copy constructor it doesnt work (creates and destroyes object).

Edit:
if i use

         Osoba(Osoba& x): Osoba(x.imie,x.wiek){

i get type 'class Osoba' is not a direct base of 'Osoba'

how is this done ?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

握住你手 2024-11-14 14:04:02

你不能这样调用构造函数。好吧，你可以，但是会发生一个无名的临时对象被创建。编写复制构造函数而不引用其他构造函数。另外，如果您使用 std::string 而不是 char *，则不需要复制构造函数。如果你坚持使用 char *，你还需要一个析构函数和一个赋值运算符。

回复收藏 0 原文

鹿童谣 2024-11-14 14:04:02

您必须初始化 Osoba 的成员，就像在其他构造函数中所做的那样。

您只能在 C++2011 中重用构造函数（使用其他语法）。

回复收藏 0 原文

远昼 2024-11-14 14:04:02

除了创建另一个不同的对象之外，您不能调用构造函数。

如果您需要在构造函数之间有一些共同的代码，您可以将其放在单独的方法中并调用该方法。请注意，在构造函数中，您可以调用对象的方法，但虚拟方法不会分派派生类。

换句话说，如果

struct Foo
{
    virtual void doit() { ... }
    Foo() {
        doit();
    }
};

struct Bar : Foo
{
    virtual void doit() { ... }
};

在 Bar 的构造函数期间调用的 doit 的实现将是 Foo 中定义的实现，因为在派生对象的基础部分，该对象只是一个“基础”对象。仅在构造函数的末尾，它在执行“派生”构造函数中的任何最终存在的代码之前才成为“派生”对象。

请注意其他面向对象语言使用不同的方法...

有关 C++ 中到底发生的情况的解释请参阅这篇文章。

如果您喜欢法律术语描述，则 C++ 标准 12.7.4 中是这样规定的：

成员函数，包括虚拟
函数（10.3），可以在期间调用
建造或破坏（12.6.2）。
当调用虚函数时
直接或间接来自
构造函数（包括来自
数据成员的内存初始化程序）或
从析构函数，以及对象
调用应用的是对象
正在建设或毁坏中，
被调用的函数是定义在
构造函数或析构函数自己的
类或其基础之一，但不是
在类中重写它的函数
从构造函数派生或
析构函数的类，或覆盖它
在其他基类之一中
最派生的对象 (1.8)。如果
虚函数调用使用显式
类成员访问（5.2.5）和
对象表达式指的是对象
正在建设或毁坏，但
它的类型既不是构造函数也不是
析构函数自己的类或其之一
基数，调用的结果是
未定义。

You cannot call a constructor except for creating another different object.

If you need to have some code in common between constructors you can place it in a separate method and call that method. Note that in the constructor you can call methods of the object but virtual methods are not going to dispatch do derived classes.

In other words if you have

struct Foo
{
    virtual void doit() { ... }
    Foo() {
        doit();
    }
};

struct Bar : Foo
{
    virtual void doit() { ... }
};

during the constructor of Bar the implementation of doit called will be the one defined in Foo because during the constructor of the base part of the derived object, the object is only a "base" object. Only at the end of the constructor it becomes a "derived" object right before executing any eventually present code in the "derived" constructor.

Be careful that other object oriented languages use a different approach...

For an explanation of what happens exactly in C++ see this article.

If you like instead a legalese description this is what is stated in the C++ standard at 12.7.4:

Member functions, including virtual
functions (10.3), can be called during
construction or destruction (12.6.2).
When a virtual function is called
directly or indirectly from a
constructor (including from the
mem-initializer for a data member) or
from a destructor, and the object to
which the call applies is the object
under construction or destruction, the
function called is the one defined in
the constructor or destructor’s own
class or in one of its bases, but not
a function overriding it in a class
derived from the constructor or
destructor’s class, or overriding it
in one of the other base classes of
the most derived object (1.8). If the
virtual function call uses an explicit
class member access (5.2.5) and the
object-expression refers to the object
under construction or destruction but
its type is neither the constructor or
destructor’s own class or one of its
bases, the result of the call is
undefined.