C++ c++；创建一个类，调用它的函数，并在一条语句中返回vector

我有一个类

MyClass

，另一个类包含

MyClass

数组，如下所示：

class MyClass {
    int a;
    float b;

    void SetInt(int value)
    {
        a = value;
    }

    void SetFloat(float value)
    {
        b = value;
    }
}

class MyClassArray {
    std::vector<MyClass> classList;
}

这有效吗

顺便说一句：我需要在

vector

中设置一个对象

MyClass

，其中

21

设置在

a

上，另一个

1.23

设置在

b

上，这就是为什么我不使用

a

和

b

的初始值设定项使用构造函数的原因

  Use your constructor 
    class MyClass {
        int a;
        float b;


    }

class MyClassArray {
    std::vector<MyClass> classList;
    classList.push_back(MyClass(21,1.23));
}

类MyClass{ INTA； 浮球b； } 类MyClassArray{ 向量类列表； 类列表。推回（MyClass（21,1.23））； }

使用您的构造函数
类MyClass{
INTA；
浮球b；
}
类MyClassArray{
向量类列表；
类列表。推回（MyClass（21,1.23））；
}

您可以为此使用构造函数。如果重载构造函数以获取

int

或

float

，则可以为您概述的两种情况设置值

class MyClass 
{
    int a;
    float b;

    MyClass(int i) : a(i) { }
    MyClass(float f) : b(f) { }
}

这样，您可以通过执行以下操作将对象添加到

向量中：

std::vector<MyClass> classList;

classList.push_back(MyClass(21));

classList.push_back(MyClass(1.23));

如果确实需要调用单独的方法，可以这样做：

class MyClass {
    int a;
    float b;

    MyClass& SetInt(int value)
    {
        a = value;
        return *this;
    }

    MyClass& SetFloat(float value)
    {
        b = value;
        return *this;
    }
}

它将返回对类的引用。不过，使用构造函数做这件事要好得多。
您可以为此使用构造函数。如果重载构造函数以获取
int
或
float
，则可以为您概述的两种情况设置值

class MyClass 
{
    int a;
    float b;

    MyClass(int i) : a(i) { }
    MyClass(float f) : b(f) { }
}

这样，您可以通过执行以下操作将对象添加到
向量中：

std::vector<MyClass> classList;

classList.push_back(MyClass(21));

classList.push_back(MyClass(1.23));

如果确实需要调用单独的方法，可以这样做：

class MyClass {
    int a;
    float b;

    MyClass& SetInt(int value)
    {
        a = value;
        return *this;
    }

    MyClass& SetFloat(float value)
    {
        b = value;
        return *this;
    }
}

它将返回对类的引用。不过，使用构造函数做这件事要好得多。
您可以使用
链接
：

class MyClass {
    int a;
    float b;
public:
    MyClass& Set(int value)   { a = value; return *this; }
    MyClass& Set(float value) { b = value; return *this; }
};

这可以实现以下功能：

MyClass a;
a.Set(1).Set(1.5f);

而且：

vector<MyClass> vec;
vec.push_back(MyClass{}.Set(3));

vec；
向量push_back（MyClass{}.Set（3））；
您可以使用
链接
：

class MyClass {
    int a;
    float b;
public:
    MyClass& Set(int value)   { a = value; return *this; }
    MyClass& Set(float value) { b = value; return *this; }
};

这可以实现以下功能：

MyClass a;
a.Set(1).Set(1.5f);

而且：

vector<MyClass> vec;
vec.push_back(MyClass{}.Set(3));

vec；
向量push_back（MyClass{}.Set（3））；
我不明白。通过
MyClass（）
的左括号，您不知道数据类型，但当您到达
MyClass（）
之后的点时，您就知道了。不。忘记最后的注释。。我只是把它拿走了…我不明白。通过
MyClass（）
的左括号，您不知道数据类型，但当您到达
MyClass（）
之后的点时，您就知道了。不。忘记最后的注释。。我刚把它取下来…多么漂亮的一个漏洞！vector不需要（也可能不应该）存储指针。这不起作用，因为我需要在
vector
上使用两个不同的类。一个
21
设置为
a
，另一个
1.23
设置为
b
。这样的话，我将有一个同时设置了
a
和
b
的类。@Mendez然后你需要更多的构造函数你不需要一个指针，那么简单，我假设OP会有意义在wards之后释放向量。如果不需要指针，请编辑。std向量析构函数调用其组成对象的析构函数，这是一个漂亮的漏洞！vector不需要（也可能不应该）存储指针。这不起作用，因为我需要在
vector
上使用两个不同的类。一个
21
设置为
a
，另一个
1.23
设置为
b
。这样的话，我将有一个同时设置了
a
和
b
的类。@Mendez然后你需要更多的构造函数你不需要一个指针，那么简单，我假设OP会有意义在wards之后释放向量。如果不需要指针，请编辑。std vector析构函数调用其组成对象的析构函数使用构造函数可能是一个问题。如果我调用MyClass（10）呢。构造函数永远不会知道我调用的是Int还是Float，可能会导致错误调用……构造函数会知道。如果您想要一个浮点值，您肯定会使用MyClass（10.0）。。。所以它必须是int.；-）@Mendez如果你调用
MyClass（10）
编译器会推断出你想要它是一个int。如果你调用
MyClass（10.0）
编译器会推断出你想要它是一个float。在前面提到的情况下，它不会知道。。。。我不能保证所有输入的值都有一个点。这是假设可能失败，对我来说，这是一个糟糕的做法。如果您想为构造函数指定不同的函数名，一个可能的解决方案是使用转发到-private！的静态成员函数构造函数：
MyClass CreateFromFloat（浮点值）{返回MyClass（值）；}
。然后可以这样使用：
classList.push_back（MyClass:：CreateFromFloat（10））。使用构造函数可能会有问题。如果我调用MyClass（10）呢。构造函数永远不会知道我调用的是Int还是Float，可能会导致错误调用……构造函数会知道。如果您想要一个浮点值，您肯定会使用MyClass（10.0）。。。所以它必须是int.；-）@Mendez如果你调用
MyClass（10）
编译器会推断出你想要它是一个int。如果你调用
MyClass（10.0）
编译器会推断出你想要它是一个float。在前面提到的情况下，它不会知道。。。。我不能保证所有输入的值都有一个点。这是假设可能失败，对我来说，这是一个糟糕的做法。如果您想为构造函数指定不同的函数名，一个可能的解决方案是使用转发到-private！的静态成员函数构造函数：
MyClass CreateFromFloat（浮点值）{返回MyClass（值）；}
。然后可以这样使用：
classList.push_back（MyClass:：CreateFromFloat（10））。