Constructor
- What does a constructor look like
-The function name is the same as the class name
-No return value
void also has a return value
-If you do not write a constructor, there is a default constructor in any class
The default constructor is parameterless
When we write the constructor, the default function is deleted
-Constructor is called by default when constructing an object
-Delete can be used to delete the default constructor
Class name () = delete;
-Specifies to use the default parameterless constructor, described with default
Class name () = default;
-Allow a constructor to call another constructor, just by initializing the parameter list
-Initialization parameter list: only constructors have
Constructor name (parameter 1, parameter 2...): member 1 (parameter 1), member 2 (parameter 2)... {} (avoid problems caused by the same formal parameter and data member) - What are constructors for
-Used to construct objects
-Constructors are more used for tree pool data members - Some thoughts on constructor
-Why not write a constructor to construct an object? (because there is a default parameterless constructor, you can only construct parameterless objects when you don't write again)
-Why should constructors be overloaded? (to construct objects with different looks)
//Initialization parameter list
class Tihu1{
public:
Tihu1(string nname = "Tihu",int nage = 19):name(nname),age(nage){}
void print(){
cout<<name<<"\t"<<age<<endl;
}
protected:
string name ;
int age ;
};
//Default of constructor
class Tihu2{
public:
Tihu2(string nname = "Tihu two",int nage = 19){
name = nname;
age = nage;
}
void print(){
cout<<name<<"\t"<<age<<endl;
}
protected:
string name ;
int age ;
};
int main(void){
Tihu1 A1("Tihu1",20);
Tihu1 A2("Tihu2",21);
Tihu2 A3;
A1.print();
A2.print();
A3.print();
return 0;
}
Destructor
- What does a destructor look like
- No return value
- No parameters
- Function name: class name
- If it is not written, there is a default destructor
- Destructors do not need to be called by themselves and are executed at the end of the object's life cycle
- What are destructors for
-When the data member in the class is a pointer, use dynamic memory to apply for writing constructors and destructors
-Freeing dynamic memory requested by data members
class Tihu2{
public:
Tihu2(const char *nname ="Tihu",int nage = 19){
name = new char[strlen(nname)+1];
strcpy(name,nname);
cout<<strlen(nname)+1<<endl;
age = nage;
}
void print(){
cout<<name<<"\t"<<age<<endl;
}
//Destructor
~Tihu2(){
cout<<"I'm a destructor"<<endl;
delete [] name;
}
protected:
char* name ;
int age ;
};
copy constructor
- The copy constructor is also a constructor. It looks the same as the constructor. It is also used to construct objects, but
Parameters are unique and are references to objects
Tihu(const Tihu& A1 ) - If it is not written, there is a default copy to construct the function, but the default is a shallow copy, which is not applicable when the element contains a pointer.
- Copy constructor is used to initialize one object with another
- const must be added when there is an anonymous object assignment operation
class Tihu
{
public:
//Definition method of copy structure
Tihu(const Tihu& A1)
{
age = A1.age;
}
protected:
int age;
}
Deep copy and shallow copy
- Shallow copy: the default copy structure is shallow copy
- Deep copy: a new memory operation is performed in the copy structure, because when the shallow copy has a pointer, it only determines the pointer, not applies for new space for the pointer, resulting in an error in memory release in the destructor
class Tihu
{
public:
Tihu(char nname[] = "Tihu",int nage = 19):age(nage)
{
name = new char[strlen(nname)+1];
strcpy(name,nname);
}
Tihu(const Tihu& A1)
{
name = new char[sizeof(*A1.name)];
strcpy(name,A1.name);
}
~Tihu()
{
delete[] name;
}
protected:
char* name;
int age;
}
Tihu A1("Tihu1",10);
Tihu A2(A1);
printf("A1.name:%p\n",A1.name);
printf("A2.name:%p\n",A2.name);
Tectonic and destructional sequence
- For ordinary objects, the construction order and destruction order are opposite
- delete will directly call the destructor for the new object
- static object. The life cycle ends when the program is closed
#include <iostream>
#include <string>
using namespace std;
class MM
{
public:
MM(string name="x") :name(name) {
cout << name;
}
~MM(){
cout << name;
}
protected:
string name;
};
int main()
{
{
MM mm1("A"); //A
static MM mm2("B"); //B program dies when it is closed, and finally destructs
MM* p3 = new MM("C"); //C
MM mm4[4]; //xxxx
delete p3; //C delete calls the destructor directly
p3 = nullptr;
//xxxxAB
}
//ABCxxxxCxxxxAB
return 0;
}
C + + structure
- If a constructor is added to the structure of c + +, the c + + class must be used. The only difference is that the default area in the structure is a public attribute, while the default area in the class is a private attribute.
task
- Implementation of mystring class
- Implement the creation method in string
- By implementing data and c_str function prints a string
- Implement the link of append string
- Implement string comparison
- Freeing memory by handwriting destructor
#include <iostream>
#include <cstring>
using namespace std;
/*
mystring Class implementation
1. Implement the creation method in string
2. By implementing data and c_str function prints a string
3. Implement the link of append string
4. Implement string comparison
5. Freeing memory by handwriting destructor
*/
class mystring
{
public:
mystring(char str1[]="Default value"){
str = new char[strlen(str1)+1];
strcpy(str,str1);
}
mystring(const mystring& object){
str = new char[strlen(object.str)+1];
strcpy(str,object.str);
}
//5. Freeing memory by handwriting destructor
~mystring(){
delete[] str;
}
char* data(){
return str;
}
char* c_str(){
return str;
}
void print(){
cout<<str<<endl;
}
mystring append(const mystring& object){
int n=strlen(str);
int sum = n+strlen(object.str)+1;
char* ptemp = new char[sum];
int i=0;
while(1){
if(i<strlen(str)){
ptemp[i] = str[i];
}
else if(i>=strlen(str)&&i<sum-1){
ptemp[i] = object.str[i-n];
}
else{
ptemp[i] = 0;
break;
}
}
mystring A1(ptemp);
delete[] ptemp;
ptemp = NULL;
return A1;
}
int compare(const mystring& object){
return strcmp(str,object.str);
}
protected:
char* str;
};
int main(){
// 1. Implement the creation method in string
mystring str1;
mystring str2("ILoveyou");
mystring str3(str1);
str3.print();
mystring str4 = str2;
str4.print();
//2. By implementing data and c_str function prints a string
cout << str2.c_str() << endl; //Print ILoveyou
cout << str2.data() << endl; //Print ILoveyou
//3. Implement the link of append string
string strOne="one";
string strTwo="two";
string strThree=strOne.append(strTwo);
cout<<strThree.data()<<endl; //onetwo
//4. String comparison
cout<<strOne.compare(strOne)<<endl; //0
cout<<strOne.compare(strTwo)<<endl; //-1
cout<<strTwo.compare(strOne)<<endl; //1
//5. Freeing memory by handwriting destructor
return 0;
}
- Operation results
