C++ 在不调用构造函数的情况下创建向量元素_C++_Class_Object_Vector_Elements

C++ 在不调用构造函数的情况下创建向量元素

c++ class object vector

C++ 在不调用构造函数的情况下创建向量元素,c++,class,object,vector,elements,C++,Class,Object,Vector,Elements,假设我有两个等级：汽车和服务。是否可以为汽车和服务类的两个矢量对象（注：我不知道是否实际被视为矢量对象）创建元素。一旦创建了这两个元素，我只希望稍后调用car类构造函数来调用服务构造函数以获取用户信息还有，如果可能的话，不必将服务构造函数更改为方法也可以吗 using namespace std; // I know this is not the best, prof wants us to use it class Car { Car() { //Get data from

假设我有两个等级：汽车和服务。是否可以为汽车和服务类的两个矢量对象（注：我不知道是否实际被视为矢量对象）创建元素。一旦创建了这两个元素，我只希望稍后调用car类构造函数来调用服务构造函数以获取用户信息

还有，如果可能的话，不必将服务构造函数更改为方法也可以吗

   using namespace std; // I know this is not the best, prof wants us to use it

   class Car { Car() { //Get data from user } };

   class Service { Service(){ //Get data from user } };

   int main () {

       int num;
       vector<Car> car; 
       vector<Service> service;

       car.push_back(Car{});
       service.push_back();

       for (int i = 0; i < car.size(); i++) 
            car[i].display(i);
       cout << endl << car.size() + 1 << ". exit";
       cin >> num;
       service[num].Service::Service();

   }

使用命名空间std；//我知道这不是最好的，教授希望我们使用它
类Car{Car（）{//从用户}获取数据}；
类服务{Service（）{//从用户}获取数据}；
int main（）{
int-num；
矢量车；
向量服务；
车。向后推（车{}）；
服务。推回（）；
对于（int i=0；icout从C++11开始，就有了向量和其他容器的列表初始化

这意味着，可以在初始化时将元素枚举放入向量中
您可以在其中使用自己的类构造函数：
std::vector<Car> cars {Car(...), Car(...), Car(...)}; //C++11

std:：vector cars{Car（…），Car（…），Car（…）}；//C++11

因为我还不能评论你的问题，这是你所期望的吗？
自从C++11以来，你就有了vector和其他容器的列表初始化

这意味着，可以在初始化时将元素枚举放入向量中
您可以在其中使用自己的类构造函数：
std::vector<Car> cars {Car(...), Car(...), Car(...)}; //C++11

std:：vector cars{Car（…），Car（…），Car（…）}；//C++11

既然我还不能评论你的问题，这是你所期望的吗？
我建议使用std:：map
，而不是std:：vector
，这是你任务中自然而然的选择。通过使用它，你将只存储有效的服务元素
   map<int,Service> service;

   car.push_back(Car{});

   for (int i = 0; i < car.size(); i++) 
        car[i].display(i);
   cout << endl << car.size() + 1 << ". exit";
   cin >> num;
   service[num]; //Service constructor will be called

地图服务；
车。向后推（车{}）；
对于（int i=0；icout我建议使用std:：map
而不是从任务中自然选择的std:：vector
。通过使用它，您将只存储有效的服务元素
   map<int,Service> service;

   car.push_back(Car{});

   for (int i = 0; i < car.size(); i++) 
        car[i].display(i);
   cout << endl << car.size() + 1 << ". exit";
   cin >> num;
   service[num]; //Service constructor will be called

地图服务；
车。向后推（车{}）；
对于（int i=0；icout我想你在找这样的东西：
class Car {
private:
    std::string _make;
    std::string _model;
    std::string _vinNumber;

    std::size_t _year;

public:
    Car() : _year( 0 ) {} // default
    Car( const std::string& make, const std::string& model, 
         const std::string& vinNumber, const std::size_t& year ) :
      _make( make ), _model( model ), 
      _vinNumber( vinNumber ), _year( year ) {
    }

    void setCarInfo( const std::string& make, const std::string& model,
                     const std::string& vinNumber, const std::size_t& year ) {
        _make      = make;
        _model     = model;
        _vinNumber = vinNumber;
        _year      = year;
    }

    std::string makeOf() const { return _make; }
    std::string modelOf() const { return _model; }
    std::string vinNumberOf() const { return _vinNumber; }
    std::size_t yearOf() const { return _year; }

};

class Service {
private:
    std::string _dealership;
    std::size_t _currentMiles;

public:
    Serivce() {}

    std::string dealershipOf() const { return _dealership; }
    std:size_t  currentMilesOf() const { return _currentMiles; }

    void setOrChangeDealership( const std::string& dealership ) {
        _dealership = dealership;
    }

    void setOrChangeCurrentMiles( std::size_t miles ) {
        _currentMiles = miles;
    }

    void setOrChangeCurrentMiles( const std::size_t& miles ) {
        _currentMiles = miles;
    }
};

int main() {
    std::vector<Car> cars;
    std::vector<Service> services;

    // you can add Car to vector by either default constructor 
    // to be filled out later or by user defined constructor
    cars.push_back( Car( "Honda", "Civic", "75273250323XMD252AG9", 2017 ) );
    // or
    cars.push_back( Car() );
    // then you can at some point in time update elements in container
    cars[i].setCarInfo( "Dodge", "Charger", "9259356M325D2680A217B", 2015 );

    // As with the service class there is only a "default" constructor
    services.push_back( Service() );
    // Service's members will have to be updated manually and later.

    return 0;
}

 A a();

编译器将在A
上调用A（）
的A；
行在幕后，因此它实际上看起来像这样：
class Car {
private:
    std::string _make;
    std::string _model;
    std::string _vinNumber;

    std::size_t _year;

public:
    Car() : _year( 0 ) {} // default
    Car( const std::string& make, const std::string& model, 
         const std::string& vinNumber, const std::size_t& year ) :
      _make( make ), _model( model ), 
      _vinNumber( vinNumber ), _year( year ) {
    }

    void setCarInfo( const std::string& make, const std::string& model,
                     const std::string& vinNumber, const std::size_t& year ) {
        _make      = make;
        _model     = model;
        _vinNumber = vinNumber;
        _year      = year;
    }

    std::string makeOf() const { return _make; }
    std::string modelOf() const { return _model; }
    std::string vinNumberOf() const { return _vinNumber; }
    std::size_t yearOf() const { return _year; }

};

class Service {
private:
    std::string _dealership;
    std::size_t _currentMiles;

public:
    Serivce() {}

    std::string dealershipOf() const { return _dealership; }
    std:size_t  currentMilesOf() const { return _currentMiles; }

    void setOrChangeDealership( const std::string& dealership ) {
        _dealership = dealership;
    }

    void setOrChangeCurrentMiles( std::size_t miles ) {
        _currentMiles = miles;
    }

    void setOrChangeCurrentMiles( const std::size_t& miles ) {
        _currentMiles = miles;
    }
};

int main() {
    std::vector<Car> cars;
    std::vector<Service> services;

    // you can add Car to vector by either default constructor 
    // to be filled out later or by user defined constructor
    cars.push_back( Car( "Honda", "Civic", "75273250323XMD252AG9", 2017 ) );
    // or
    cars.push_back( Car() );
    // then you can at some point in time update elements in container
    cars[i].setCarInfo( "Dodge", "Charger", "9259356M325D2680A217B", 2015 );

    // As with the service class there is only a "default" constructor
    services.push_back( Service() );
    // Service's members will have to be updated manually and later.

    return 0;
}

 A a();

使用它的默认构造函数。
我想您正在寻找这样的东西：
class Car {
private:
    std::string _make;
    std::string _model;
    std::string _vinNumber;

    std::size_t _year;

public:
    Car() : _year( 0 ) {} // default
    Car( const std::string& make, const std::string& model, 
         const std::string& vinNumber, const std::size_t& year ) :
      _make( make ), _model( model ), 
      _vinNumber( vinNumber ), _year( year ) {
    }

    void setCarInfo( const std::string& make, const std::string& model,
                     const std::string& vinNumber, const std::size_t& year ) {
        _make      = make;
        _model     = model;
        _vinNumber = vinNumber;
        _year      = year;
    }

    std::string makeOf() const { return _make; }
    std::string modelOf() const { return _model; }
    std::string vinNumberOf() const { return _vinNumber; }
    std::size_t yearOf() const { return _year; }

};

class Service {
private:
    std::string _dealership;
    std::size_t _currentMiles;

public:
    Serivce() {}

    std::string dealershipOf() const { return _dealership; }
    std:size_t  currentMilesOf() const { return _currentMiles; }

    void setOrChangeDealership( const std::string& dealership ) {
        _dealership = dealership;
    }

    void setOrChangeCurrentMiles( std::size_t miles ) {
        _currentMiles = miles;
    }

    void setOrChangeCurrentMiles( const std::size_t& miles ) {
        _currentMiles = miles;
    }
};

int main() {
    std::vector<Car> cars;
    std::vector<Service> services;

    // you can add Car to vector by either default constructor 
    // to be filled out later or by user defined constructor
    cars.push_back( Car( "Honda", "Civic", "75273250323XMD252AG9", 2017 ) );
    // or
    cars.push_back( Car() );
    // then you can at some point in time update elements in container
    cars[i].setCarInfo( "Dodge", "Charger", "9259356M325D2680A217B", 2015 );

    // As with the service class there is only a "default" constructor
    services.push_back( Service() );
    // Service's members will have to be updated manually and later.

    return 0;
}

 A a();

编译器将在A
上调用A（）
的A；
行在幕后，因此它实际上看起来像这样：
class Car {
private:
    std::string _make;
    std::string _model;
    std::string _vinNumber;

    std::size_t _year;

public:
    Car() : _year( 0 ) {} // default
    Car( const std::string& make, const std::string& model, 
         const std::string& vinNumber, const std::size_t& year ) :
      _make( make ), _model( model ), 
      _vinNumber( vinNumber ), _year( year ) {
    }

    void setCarInfo( const std::string& make, const std::string& model,
                     const std::string& vinNumber, const std::size_t& year ) {
        _make      = make;
        _model     = model;
        _vinNumber = vinNumber;
        _year      = year;
    }

    std::string makeOf() const { return _make; }
    std::string modelOf() const { return _model; }
    std::string vinNumberOf() const { return _vinNumber; }
    std::size_t yearOf() const { return _year; }

};

class Service {
private:
    std::string _dealership;
    std::size_t _currentMiles;

public:
    Serivce() {}

    std::string dealershipOf() const { return _dealership; }
    std:size_t  currentMilesOf() const { return _currentMiles; }

    void setOrChangeDealership( const std::string& dealership ) {
        _dealership = dealership;
    }

    void setOrChangeCurrentMiles( std::size_t miles ) {
        _currentMiles = miles;
    }

    void setOrChangeCurrentMiles( const std::size_t& miles ) {
        _currentMiles = miles;
    }
};

int main() {
    std::vector<Car> cars;
    std::vector<Service> services;

    // you can add Car to vector by either default constructor 
    // to be filled out later or by user defined constructor
    cars.push_back( Car( "Honda", "Civic", "75273250323XMD252AG9", 2017 ) );
    // or
    cars.push_back( Car() );
    // then you can at some point in time update elements in container
    cars[i].setCarInfo( "Dodge", "Charger", "9259356M325D2680A217B", 2015 );

    // As with the service class there is only a "default" constructor
    services.push_back( Service() );
    // Service's members will have to be updated manually and later.

    return 0;
}

 A a();

使用其默认构造函数。
您是否正在寻找std:vector
？请参阅。请描述您试图更好地解决的问题（问题描述，最小化，而不是您试图在代码中执行的操作）在对象的构造中，不必从用户那里获取输入，而是编写一个函数，它要求您所需要的，然后将其传递给对象的构造函数。然后，您可以返回该对象并使用它将其分配给您想要的向量元素。您应该开始阅读C++的初学者书籍。什么是继承，什么是OOP？第二次调用一个构造函数“有时会晚些”，这绝对是C++工作的错误想法。所以你应该从基本的开始，直到构造函数运行之前你不能有一个对象。为什么不把默认的构造函数中的<代码> //数据从用户< /代码>移到函数<代码> Car GETCARFRONMIN（）中。
和服务getServiceFromInput（）
？您是否正在寻找标准：向量
？请参阅。请描述您试图更好地解决的问题（问题描述，最小化，而不是您试图在代码中执行的操作）在对象的构造中，不必从用户那里获取输入，而是编写一个函数，它要求您所需要的，然后将其传递给对象的构造函数。然后，您可以返回该对象并使用它将其分配给您想要的向量元素。您应该开始阅读C++的初学者书籍。什么是继承，什么是OOP？第二次调用一个构造函数“有时会晚些”，这绝对是C++工作的错误想法。所以你应该从基本的开始，直到构造函数运行之前你不能有一个对象。为什么不把默认的构造函数中的<代码> //数据从用户< /代码>移到函数<代码> Car GETCARFRONMIN（）中。
和服务getServiceFromInput（）
？我想为我的两个类都创建对象，这两个类都有构造函数。我希望两个对象都添加元素，尽管我只希望调用汽车类构造函数，而不希望调用服务类构造函数。我想为我的两个类都创建对象，这两个类都有构造函数我希望两个对象都添加元素，尽管我只希望调用car类构造函数，而不希望调用服务类构造函数。