Using destructor

[desktop]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;
};

int main() {

MyArray myarr(5);
return 0;
}

But when are the destructor called?

 

[Devon Null]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;
};

int main() {

MyArray myarr(5);
return 0;
}

But when are the destructor called?

The destructor is called implicitly when the object is distroyed - how
it is destroyed does not matter.

 

[Daniel T.]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;
};

int main() {

MyArray myarr(5);
return 0;
}

But when are the destructor called?

When "myarr" goes out of scope.

 

[Salt_Peter]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

MyArray(const int a) : data(new int[a]) { }

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;

};

int main() {

MyArray myarr(5);
return 0;

}

But when are the destructor called?

The destructor is invoked when the object goes out of scope. In this
case it happens when main returns. Add an output (std::cout <<
"~MyArray()" to your d~tor to see it.

Did you mean to write int& MyArray:perator[](int a) { ... } ?

 

[archimed7592]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;
};

int main() {

MyArray myarr(5);
return 0;
}

But when are the destructor called?

The destructor is called implicitly when the object is distroyed - how
it is destroyed does not matter.

btw, you can invoke destructor explicitly:
myarr.~MyArr();
note: in member functions you should write 'this->~MyArray();'. not
'~MyArray()' (without 'this->')

 

[Rolf Magnus]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;
};

int main() {

MyArray myarr(5);
return 0;
}

But when are the destructor called?

The destructor is called implicitly when the object is distroyed - how
it is destroyed does not matter.

btw, you can invoke destructor explicitly:
myarr.~MyArr();
note: in member functions you should write 'this->~MyArray();'. not
'~MyArray()' (without 'this->')

Note however that this is almost never a good idea.

 

[Salt_Peter]

I have this class:
class MyArray {
public:
MyArray(int a) : data(new int[a]){}
~MyArray() {delete[] data;}
int& operator()(int a){
return data[a];
}
int operator()(int a) const{
return data[a];
}
private:
int* data;
};
int main() {
MyArray myarr(5);
return 0;
}
But when are the destructor called?

The destructor is called implicitly when the object is distroyed - how
it is destroyed does not matter.

btw, you can invoke destructor explicitly:

and you can also jump off a skyscraper without a parachute.

myarr.~MyArr();
note: in member functions you should write 'this->~MyArray();'. not
'~MyArray()' (without 'this->')

If a user of the class needs to manage the lifetime of an object, he/
she should be doing it through dynamic allocation using smart pointers
or new/delete.

 

[Jim Langston]

I have this class:

class MyArray {
public:
MyArray(int a) : data(new int[a]){}

~MyArray() {delete[] data;}

int& operator()(int a){
return data[a];
}

int operator()(int a) const{
return data[a];
}

private:
int* data;
};

int main() {

MyArray myarr(5);
return 0;

Here is where the destructor is called. This return statement is exiting
the function main, myarr goes out of scope, so it's destructor is called.