Question

在C＃中，我知道您可以使用default keyword将默认值指定为0到值类型，将null指定为引用类型，对于结构类型，可以相应地分配单个成员。据我所知，C ++中没有默认值。在使用C ++编程时，您将采用什么方法来获取与Generics的默认关键字相同的功能？

Answer 1

假设类型是default-constructible，您可以使用值初始化。例如，

template <typename T>
T get()
{
    return T(); // returns a value-initialized object of type T
}

如果类型不是默认构造的，通常需要提供默认使用。例如，

template <typename T>
T get(const T& default_value = T())
{
    return default_value;
}

如果类型是default-constructible，则可以不带参数调用此函数。对于其他类型，您可以提供要返回的值。

Answer 2

C ++没有default关键字，因为它没有引用和值类型之间的区别。在C ++中，所有类型都是C＃会考虑的值类型，如果它们是默认构造的（作为内置类型，POD结构和具有默认构造函数的类类型），则使用值初始化（默认构造函数语法）初始化它们。正如James McNellis所说:(并且无耻地复制在这里）

template <typename T>
T get()
{
    return T(); // returns a value-initialized object of type T
}

如果T具有默认构造函数，则调用它。如果它没有构造函数，则所有内容都初始化为零/ null。

如果类型不是默认可构造的，那么没有默认值可以给出对象。

Answer 3

使用默认构造函数，即使您最后离开()，也会使用它：

#include <iostream>
class MyClass {
    public:
    int x;
    MyClass(){
        x = 5;
    }
};

int main(){
    MyClass y;
    std::cout << y.x;
}

Answer 4

在C ++中，为全局范围或函数中的变量分配默认值非常简单：

int myint=2;
float* pfloat=NULL;

对于类成员，您需要在类的构造函数中初始化它们：

class myclass {
private:
  int i;
public:
  myclass() {
    i = 4;
  }
};

我不确定结构。

Answer 5

以下是C ++ 03中初始化技术的快速摘要。

对T类型的对象进行零初始化意味着： - 如果T是标量类型（3.9），则将对象设置为值0（零）转换为T;
— if T is a non-union class type, each nonstatic data member and each base-class subobject is zeroinitialized;

— if T is a union type, the object’s first named data member89) is zero-initialized;

— if T is an array type, each element is zero-initialized;

— if T is a reference type, no initialization is performed.

默认初始化T类型的对象意味着：

— if T is a non-POD class type (clause 9), the default constructor for T is called (and the initialization is ill-formed if T has no accessible default constructor);

— if T is an array type, each element is default-initialized;

— otherwise, the object is zero-initialized.

对T类型的对象进行值初始化意味着：＆GT;

— if T is a class type (clause 9) with a user-declared constructor (12.1), then the default constructor for T is called (and the initialization is ill-formed if T has no accessible default constructor);

— if T is a non-union class type without a user-declared constructor, then every non-static data member and base-class component of T is value-initialized;

— if T is an array type, then each element is value-initialized;

— otherwise, the object is zero-initialized

有了这个理解

struct S{
   int x;
   S():x(1){}
};

S sg;                    // Every object of static storage duration is zero initialized at program startup before any other initialization takes place. So 'x' is initialized to 0, before the default constructor runs and sets 'x' to 1.

int main{
   int x = int();        // value initialization syntax, as per rules above is initialized to 0.

    S sl;                // default initialized
}

Answer 6

在C ++中，您通常会调用默认构造函数（可以不带参数调用的构造函数）。这也适用于原始类型（即int()为0，int*()为空指针等。）。

例如，在您的模板函数中，您可以编写如下内容：

template<typename T>
T foo()
{
    T x = T(); // See notes below about this.

    // Do other stuff.

    return x;
}

请注意，T x;本身就足以隐式调用非POD类型的默认构造函数，但这对原始标量类型（例如int）不起作用它将被初始化为垃圾。（T x()也行不通; that would be interpreted as a function declaration。）

Answer 7

这是个好问题。 c ++类型变体的完整性使得编写这种类型的安全模板成为一种痛苦。

template <typename T> struct FrameworkTemplate {
 T mInstance;
};

从理论上讲，用户可以将您的类模板实例化为

// assume A is a known default constructible type
FrameworkTemplate<A>
FrameworkTemplate<const A>
FrameworkTemplate<A const *>
FrameworkTemplate<A const &> // and so on

其中最后三个不是默认可构造的，尽管A可能是。这就是为什么有用的泛型类型，如any，nullable，lazy等，尽管在第一眼看上简单直观，但在c ++中实现（安全）并非易事...... / p>

C＃在C ++中的默认关键字等价物？

7 个答案: