在 C++ 中声明实例变量而不构造它们的好方法是什么？ [关闭]

Question

我一直在互联网上搜索这个主题，但我还没有真正找到一个确定的答案。作为主要的 C# 程序员，我习惯于在大范围内声明类，通常在文件顶部附近，在任何函数之外，然后在使用时构造它们。

在转向 C++ 之后，复制它的唯一方法是拥有一个默认构造函数，这很好，但在某些情况下，我宁愿拥有一个需要参数的构造函数，而不是一个无参数的默认构造函数。

在互联网上搜索解决方案后，我遇到了一些建议，它们有缺陷：

1.指针

有人建议在想要的范围内有一个动态指针，然后在构造的时候将指针指向类的位置。

CClass* pClass = 0;

int main()
{
    pClass = new CClass(1337);

    delete pClass;
    return 0;
}

这种方法的问题是你必须记住在之后删除指针，因此，静态指针更“安全”。另外，我猜这样做会产生轻微的内存开销，尽管不会太多，因为有指针。

2。无论如何都有一个默认构造

有时建议使用默认构造函数，它将类中的所有内容归零：

class CClass
{
public:
    CClass() : leetNumber(0) {}
    CClass(int leetNumber) : leetNumber(leetNumber) {}
private:
    int leetNumber;
};

//Defaults leetNumber to 0 through default ctor
CClass myClass;

int main()
{
    myClass = CClass(1337);

    return 0;
}

但是，如果您不能将课堂内的所有内容都归零，会发生什么？如果你有另一个类不能被初始化为空怎么办？如果用户试图在没有正确初始化成员的情况下访问类中的函数，你会怎么做？ （你可以检查一下，但我相信这需要太多代码，尤其是如果你有很多成员）。

3.停留在更小、更本地化的范围内

有人建议人们说要保持在小范围内，将类作为引用传递给可能需要它的其他函数，并在声明类后立即构造：

class CClass
{
public:
    CClass(int leetNumber) : leetNumber(leetNumber) {}
    int getLeetNumber() { return leetNumber; }
private:
    int leetNumber;
};

bool GetMuchNeededAmazingNumberFromClass(CClass& myClass)
{
    if(myClass.getLeetNumber() == 1337)
        return true;

    return false;
}

int main()
{
    CClass myClass = CClass(1337);
    if(!GetMuchNeededAmazingNumberFromClass(&myClass);
        return 1;

    return 0;
}

从某种意义上说，这很好，您可以看到什么函数需要什么，但我可以想象一个函数需要大量具有大量所需参数的外部类。

还有更多示例，但我似乎找不到可以依赖的示例，尤其是来自 C# 背景的示例，这些示例既好用又简单。

谢谢。

编辑：

让我详细说明我的要求 - 在 C# 中，您可以执行以下操作：

public class Program
{
    //See how I'm able to do this, without calling the ctor.
    static AmazingClass amazing;

    public static void Main()
    {
        //And then call the constructor when I want.
        amazing = new AmazingClass(1337);
    }
}

这允许我创建类而不实际构造它，这就是我在 C++ 中寻找的。​​p>

再次感谢。

Answer 1

听起来你想重载构造函数。

Answer 2

在函数中使用静态变量将对象的创建延迟到需要时。

Foo & getInstance () {
    static Foo foo(arg1, arg2, ...);
    return foo;
}

void main () {
    Foo & x = getInstance();
}

---

如果你需要getInstance创建一个动态对象（如getInstance(x, y, z)），但只想传入一次参数，你可以这样做：

struct FooFactory {
    int arg1;
    float arg2;
    Bar arg3;

    bool valid;

    FooFactory ();

    Foo & getInstance ();
};

FooFactory::FooFactory () : valid(false) {}

Foo & FooFactory::getInstance () {
    if (!valid) throw Error();
    static Foo foo(arg1, arg2, arg3);
    return foo;
}

FooFactor factory;

void main () {
    factory.arg1 = ...;
    factory.arg2 = ...;
    factory.arg3 = ...;
    factory.valid = true;
    Foo & x = factory.getInstance();
}

---

当然这是基础。我不在乎信息隐藏或类似的事情。您可以通过使用operator() () 而不是getInstance () 并将factory 重命名为getInstance 来避免factory.getInstance()。我也不是说这是个好主意。我只是在展示如何从字面上完成 OP 的问题。

Answer 3

这是个很坏的习惯（用对象代替类）：

我习惯于在一个大的 范围，通常在文件顶部附近，在任何函数之外，以及 然后在使用时构建它们。

忘记它。在需要时定义对象。

int main() { 
     A a;
     ...a...
     A b;
     ...b...
 }

这是 C++ 的想法。

我相信 C# 也是一个坏习惯。如果你使用对象而不定义它怎么办——你会得到空引用异常——为什么要玩这么危险的东西。

顺便说一句，C++ 等价于 C# 对象是 shared_ptr：

std::shared_ptr<A> a;
int main() {
   a = std::make_shared<A>(...);
   // do not need to call delete
}

在 C++ 中，如果您不需要共享对象，也可以使用 std::unique_ptr。

但是不要这样做，不要使用全局变量...

Answer 4

1. 停留在更小、更本地化的范围内

这是您应该做的，不仅在 C++ 中，而且在所有语言中都应尽可能多地使用。

但我可以想象一个需要大量外部类的函数，这些类具有大量所需的参数。

函数应该接受他们需要接受的参数。如果您觉得太多，也许您应该将该功能重构为其他部分。参数的数量只是衡量函数复杂性的一种方式。访问全局对象不仅不会简化函数，还会使识别全局对象的使用/访问/修改位置变得更加困难，进而使您的代码更难维护。

如果你的函数有很多参数，要么它不是一个真正的函数，而是不同操作的复杂混乱，要么参数可能组合成一些有意义的实体。在后一种情况下，只需创建代表这些实体的类型，您最终会传递一些参数。

顺便说一句，我不确定在 C# 中你是否真的按照你所说的去做......特别是，C# 中的大多数代码都在类中，所以很可能你习惯做的是拥有类成员在顶部声明并在其他任何地方使用。如果是这种情况，您可以在 C++ 中应用相同的范例。创建类，包含您需要的成员数量。

Answer 5

这是因为在 C# 中，类是基于堆的引用对象。所以：

C#

MyClass a; //null reference
a = new MyClass (param1, param2);

但是：

C++

MyClass a; //Myclass is constructed on stack

C# 版本相当于 C++ 中的这个：

Myclass* a = 0; //null reference
a = new Myclass (param1, param2);

在 C++ 中，类可以存在于堆栈中，而在 C# 中则不能。

C# 提供了一种可以存在于栈中的结构值类型：

MyStruct a; //lives on the stack

但是我可以提供一个带参数的结构构造函数：

struct MyStruct
{
   public MyStruct (int a, int b) { /*assign to members vars*/ }

   int A, B;
}

C#代码：

MyStruct a; // this creates a on stack and zero initializes int A and B

这个：

MyStruct a; //does same as above

a = new Mystruct(1, 2); //a.A = 1, a.B = 2

Answer 6

//See how I'm able to do this, without calling the ctor.
static AmazingClass amazing;

//And then call the constructor when I want.
amazing = new AmazingClass(1337);

一切（嗯，几乎一切）都是 C# 中的引用。该变量amazing 不会引用任何内容，直到您通过new 分配它。这是 C++ 的等价物：

//See how I'm able to do this, without calling the ctor.
static AmazingClass * amazing;

//And then call the constructor when I want.
amazing = new AmazingClass(1337);

因为（几乎）所有内容都是 C# 和 Java 中的引用，所以您必须 new 这个、new 那、new 这些语言中的所有内容。通过将所有内容都设为指针，您可以在 C++ 中获得相同的行为，但这样做不是首选机制。 C++ 没有自动垃圾收集。您在 C++ 中通过new 分配的所有内容最终都必须通过delete 删除。 C++ 中的首选机制是将new 和delete 保持在最低限度。

在 C++ 中解决 new / delete 问题的一种方法是绕过 new。只需声明所需类型的变量。这为您提供了一些您在 Java 和 C# 中无法做到的事情。您可以声明一个类型的变量，但 Java 和 C# 不允许您看到对象本身。这些语言中的对象总是隐藏在引用后面。

解决 C++ 中 new / delete 问题的另一种方法是使用 RAII。 new 和 delete 命令隐藏在类方法中，析构函数总是在自己之后清理。班级做肮脏的工作。对外界来说，你只需要使用这个类。

C# 和 C++ 是不同的语言。您必须采用不同的思维方式才能正确使用两种语言。