Cpp create new object

Cpp create new object

Конструкторы представляют специальную функцию, которая имеет то же имя, что и класс, которая не возвращает никакого значения и которая позволяют инициалилизировать объект класса во время го создания и таким образом гарантировать, что поля класса будут иметь определенные значения. При каждом создании нового объекта класса вызывается конструктор класса.

В прошлой теме был разработан следующий класс:

#include class Person < public: std::string name; unsigned age; void print() < std::cout >; int main() < Person person; // вызов конструктора person.name = "Tom"; person.age = 22; person.print(); >

Здесь при создании объекта класса Person, который называется person

вызывается конструктор по умолчанию . Если мы не определяем в классе явным образом конструктор, как в случае выше, то компилятор автоматически компилирует конструктор по умолчанию. Подобный конструктор не принимает никаких параметров и по сути ничего неи делает.

Теперь определим свой конструктор. Например, в примере выше мы устанавливаем значения для полей класса Person. Но, допустим, мы хотим, чтобы при создании объекта эти поля уже имели некоторые значения по умолчанию. Для этой цели определим конструктор:

#include class Person < public: std::string name; unsigned age; void print() < std::cout Person(std::string p_name, unsigned p_age) < name = p_name; age = p_age; std::cout >; int main() < Person tom("Tom", 38); // создаем объект - вызываем конструктор tom.print(); >

Теперь в классе Person определен конструктор:

Person(std::string p_name, unsigned p_age)

По сути конструктор представляет функцию, которая может принимать параметры и которая должна называться по имени класса. В данном случае конструктор принимает два параметра и передает их значения полям name и age, а затем выводит сообщение о создании объекта.

Если мы определяем свой конструктор, то компилятор больше не создает конструктор по умолчанию. И при создании объекта нам надо обязательно вызвать определенный нами конструктор.

Вызов конструктора получает значения для параметров и возвращает объект класса:

После этого вызова у объекта person для поля name будет определено значение «Tom», а для поля age — значение 38. Вполедствии мы также сможем обращаться к этим полям и переустанавливать их значения.

В качестве альтернативы для создания объекта можно использовать инициализатор в фигурных скобках:

Тажке можно присвоить объекту результат вызова конструктора:

По сути она будет эквивалетна предыдущей.

Консольный вывод определенной выше программы:

Person has been created Name: Tom Age: 38

Конструкторы облегчают нам создание нескольких объектов, которые должны иметь разные значения:

#include class Person < public: std::string name; unsigned age; void print() < std::cout Person(std::string p_name, unsigned p_age) < name = p_name; age = p_age; std::cout >; int main() < Person tom; Person bob; Person sam; tom.print(); bob.print(); sam.print(); >

Здесь создаем три разных объекта класса Person (условно трех разных людей), и соответственно в данном случае консольный вывод будет следующим:

Person has been created Person has been created Person has been created Name: Tom Age: 38 Name: Bob Age: 42 Name: Sam Age: 25

Определение нескольких конструкторов

Подобным образом мы можем определить несколько конструкторов и затем их использовать:

#include class Person < std::string name<>; unsigned age<>; public: void print() < std::cout Person(std::string p_name, unsigned p_age) < name = p_name; age = p_age; >Person(std::string p_name) < name = p_name; age = 18; >Person() < name = "Undefined"; age = 18; >>; int main() < Person tom; // вызываем конструктор Person(std::string p_name, unsigned p_age) Person bob; // вызываем конструктор Person(std::string p_name) Person sam; // вызываем конструктор Person() tom.print(); bob.print(); sam.print(); >

В классе Person определено три конструктора, и в функции все эти конструкторы используются для создания объектов:

Name: Tom Age: 38 Name: Bob Age: 18 Name: Undefined Age: 18

Хотя пример выше прекрасно работает, однако мы можем заметить, что все три конструктора выполняют фактически одни и те же действия — устанавливают значения переменных name и age. И в C++ можем сократить их определения, вызова из одного конструктора другой и тем самым уменьшить объем кода:

#include class Person < std::string name<>; unsigned age<>; public: void print() < std::cout Person(std::string p_name, unsigned p_age) < name = p_name; age = p_age; std::cout Person(std::string p_name): Person(p_name, 18) // вызов первого конструктора < std::cout Person(): Person(std::string("Undefined")) // вызов второго конструктора < std::cout >; int main() < Person sam; // вызываем конструктор Person() sam.print(); >

Запись Person(string p_name): Person(p_name, 18) представляет вызов конструктора, которому передается значение параметра p_name и число 18. То есть второй конструктор делегирует действия по инициализации переменных первому конструктору. При этом второй конструктор может дополнительно определять какие-то свои действия.

Таким образом, следующее создание объекта

будет использовать третий конструктор, который в свою очередь вызывает второй конструктор, а тот обращается к первому конструктору.

Данная техника еще называется делегированием конструктора , поскольку мы делегируем инициализацию другому конструктору.

Параметры по умолчанию

Как и другие функции, конструкторы могут иметь параметры по умолчанию:

#include class Person < std::string name; unsigned age; public: // передаем значения по умолчанию Person(std::string p_name = "Undefined", unsigned p_age = 18) < name = p_name; age = p_age; >void print() < std::cout >; int main() < Person tom; Person bob; Person sam; tom.print(); // Name: Tom Age: 38 bob.print(); // Name: Bob Age: 18 sam.print(); // Name: Undefined Age: 18 >

Инициализация констант и списки инициализации

В теле конструктора мы можем передать значения переменным класса. Однако константы требуют особого отношения. Например, вначале определим следующий класс:

class Person < const std::string name; unsigned age<>; public: void print() < std::cout Person(std::string p_name, unsigned p_age) < name = p_name; age = p_age; >>;

Этот класс не будет компилироваться из-за отсутствия инициализации константы name. Хотя ее значение устанавливается в конструкторе, но к моменту, когда инструкции из тела конструктора начнут выполняться, константы уже должны быть инициализированы. И для этого необходимо использовать списки инициализации :

#include class Person < const std::string name; unsigned age<>; public: void print() < std::cout Person(std::string p_name, unsigned p_age) : name  < age = p_age; >>; int main() < Person tom; tom.print(); // Name: Tom Age: 38 >

Списки инициализации представляют перечисления инициализаторов для каждой из переменных и констант через двоеточие после списка параметров конструктора:

Person(std::string p_name, unsigned p_age) : name

Здесь выражение name позволяет инициализировать константу значением параметра p_name. Здесь значение помещается в фигурные скобки, но также можно использовать кргулые:

Person(std::string p_name, unsigned p_age) : name(p_name)

Списки инициализации пободным образом можно использовать и для присвоения значений переменным:

class Person < const std::string name; unsigned age; public: void print() < std::cout Person(std::string p_name, unsigned p_age) : name(p_name), age(p_age) < >>;

При использовании списков инициализации важно учитывать, что передача значений должна идти в том порядке, в котором константы и переменные определены в классе. То есть в данном случае в классе сначала определена константа name, а потом переменная age. Соответственно в таком же порядке идет передача им значений. Поэтому при добавлении дополнительных полей или изменения порядка существующих придется следить, чтобы все инициализировалось в належащем порядке.

Источник

C++ Classes and Objects

Everything in C++ is associated with classes and objects, along with its attributes and methods. For example: in real life, a car is an object. The car has attributes, such as weight and color, and methods, such as drive and brake.

Attributes and methods are basically variables and functions that belongs to the class. These are often referred to as «class members».

A class is a user-defined data type that we can use in our program, and it works as an object constructor, or a «blueprint» for creating objects.

Create a Class

To create a class, use the class keyword:

Example

Create a class called » MyClass «:

class MyClass < // The class
public: // Access specifier
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
>;

Example explained

• The class keyword is used to create a class called MyClass .
• The public keyword is an access specifier, which specifies that members (attributes and methods) of the class are accessible from outside the class. You will learn more about access specifiers later.
• Inside the class, there is an integer variable myNum and a string variable myString . When variables are declared within a class, they are called attributes.
• At last, end the class definition with a semicolon ; .

• Structures are much simpler than objects. Unlike objects, structures cannot do encapsulation, inheritance or polymorphism, which you will learn more about in the next chapters. If all you need is a collection of variables, a structure is easier to use than an object.

Create an Object

In C++, an object is created from a class. We have already created the class named MyClass , so now we can use this to create objects.

To create an object of MyClass , specify the class name, followed by the object name.

To access the class attributes ( myNum and myString ), use the dot syntax ( . ) on the object:

Example

Create an object called » myObj » and access the attributes:

class MyClass < // The class
public: // Access specifier
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
>;

int main() MyClass myObj; // Create an object of MyClass

// Access attributes and set values
myObj.myNum = 15;
myObj.myString = «Some text»;

Multiple Objects

You can create multiple objects of one class:

Example

// Create a Car class with some attributes
class Car public:
string brand;
string model;
int year;
>;

int main() // Create an object of Car
Car carObj1;
carObj1.brand = «BMW»;
carObj1.model = «X5»;
carObj1.year = 1999;

// Create another object of Car
Car carObj2;
carObj2.brand = «Ford»;
carObj2.model = «Mustang»;
carObj2.year = 1969;

Источник

How to create an object in C++

In this discussion, let’s understand different ways of creating objects in C++. First, let’s know a few things about a class and an object.

Every entity, whether living or not, may be represented as an object using C++. Let’s look at an example to better understand classes and objects.

All animals in the animal kingdom have some colour and frequently engage in behaviours including eating, sleeping, and walking. And although the species in this class go by various names, they all exhibit the same behaviour and properties.

A class can be defined as a blueprint with certain characteristics (data members) and behaviours (member functions) shared by all class objects. So, In order to build reusable code, it’s necessary for us to learn how to create classes and objects in C++.

Ways to create objects in C++ :

There are two ways to build objects in C++. The only difference is where they will be stored, or where the memory for those objects will be allocated.

Objects are stored in a stack during static initialization and have an automatic storage duration, i.e., the object will be destroyed automatically at the end of the scope, but during dynamic initialization, objects are stored in a heap and we must manually delete the object after use.

In this example, let’s create a class book going into detail about how to create an object.

class book < int pages; public: void set(int pages) < this->pages = pages; cout >;

The book class contains data member pages and a member method named set. We will use the two techniques discussed above for this book class to create objects.

Dynamic way :

class_name *object_name = new class_name(); delete object_name;

#include using namespace std; class book < int pages; public: void set(int pages) < this->pages = pages; cout >; int main() < book obj1; //static storage object obj1.set(200); //to access the functions in class book* obj2 = new book(); // dynamic storage object obj2->set(400); //to access the functions in class delete obj2;// deleting dynamic storage object return 0; >

No. of pages in the book are 200 No. of pages in the book are 400

Since obj1 is created statically, no need to delete it manually. Whereas, obj2 should be deleted explicitly as it was created dynamically. We have used the new keyword and a pointer to dynamically create/instantiate the objects. Instantiation is a process of creating new objects of a class, where objects are known as instances of a class. In this process, the constructor is invoked automatically and memory is allocated for that object. Constructors are generally used to initialize the data members of the new object and it has the same name as the class name.

Create Object Through different types of constructors :

• Through Default Constructors like the one we have discussed in the above example
• Through Parameterized constructors. Here we will explicitly create a constructor in the class with some parameters which are used to initialize the data members of the class.
• Through Copy constructors. Generally, The copy constructor is a constructor that creates an object by initialising it with an object of the same class that is already created. Let’s understand how to create an object using parameterized constructor and copy the constructor using a simple code.

#include using namespace std; class book < string author; public: book(string author) < this->author = author; cout book(book& obj) < author = obj.author; cout ; >; int main() < book obj1("A.V.Thomas"); //static storage object with parameter book* obj2= new book("A.V.R.S.Stefen"); // dynamic storage object with parameter book obj3(obj1); // copy constructor //we can also use book obj3 = obj1; book* obj4 = new book(*obj2); // copy constructor delete obj2; delete obj4;// deleting dynamic storage object return 0; >

Book Author was : A.V.Thomas Book Author was : A.V.R.S.Stefen In copy constructor Book Author was : A.V.Thomas In copy constructor Book Author was : A.V.R.S.Stefen

In the above example, obj1 is created by static memory allocation through a parametrized constructor where the string “A.V.Thomas” is passed as a parameter. and this is passed as a parameter for the obj3 copy constructor. Similarly, obj2 is created dynamically with parameterized constructor where the string “A.V.R.S.Stefen” is passed as a parameter and that obj2 is passed as a parameter to copy the constructor of obj4.

Источник