Is there any point me adding a....

For my class, I was ponderng adding a deconstructor. But would that just be plain redundant? I have no objects to destroy here, What do you think?

Code:

#include <iostream>

using std::cout;
using std::endl;

// create the class

class Vehicle				// class name
{
public:
	int passengers;			// number of passengers
	int fuelcap;			// fuel capacity in gallons
	int mpg;				// fuel used ( miles per gallon )

	// this is a constructor for Vehicle

	Vehicle ( int p, int f, int m );

	int range();			// compute and return the range

};							// end class vehicle

// implement the Vehicle constructor

Vehicle::Vehicle( int p, int f, int m )
{
	passengers = p;
	fuelcap = f;
	mpg = m;
}

// implement the range() member function

int Vehicle::range()
{
	return mpg * fuelcap;
}

// main function

int _tmain(int argc, _TCHAR* argv[])
{
	// pass values to Vehicle constructor

	Vehicle miniVan ( 7, 16, 21 );	
	Vehicle sportsCar ( 2, 14, 12 );	

	int range;			// for first object
	int range2;			// for second object

	// compute the range assuming a full tank of gas
	// for miniVan and sportsCar

	range = miniVan.range();
	range2 = sportsCar.range();

	// output results to screen

	cout << "A mini van can carry " << miniVan.passengers << " with a range of " << range << endl;
	cout << "\nA sports car can carry " << sportsCar.passengers << " with a range of " << range2 << endl;

	getchar();	// freeze output

	return 0;	// indicates sucsessful termination
}

If there's nothing to release on destroying the object, there's no use for a destructor.
You could add one as a placeholder for future implementation, doing nothing right not, but the verdict is out on whether that's best practice or not.

If you always have them, even when not strictly necessary, then it becomes a good habit.
As such, you're not going to forget to add one when it does become necessary.

deconstructor.

It's called a d-e-s-t-r-u-c-t-o-r.

I have no objects to destroy here

Yes, you do:

Code:

Vehicle miniVan ( 7, 16, 21 );	
Vehicle sportsCar ( 2, 14, 12 );

All objects that are created have to be destroyed. However, the compiler supplies your class with a default destructor, and it calls the default destructor when your objects go out of scope. To see that in effect, create a destructor for your class that cout's a message to the screen, and you will see that it is called for all your objects.

As you learn more about C++, you will learn about the various default constructors and destructors that the compiler supplies for your class.

those objects have however no dynamically allocated memory so there's precious little for a destructor to do.

If there's precious little to do, then there's precious little code:

Code:

~Vehicle() {}

I would simply add three comments. One to say that the default destructor is sufficient. One to say that the default copy constructor is sufficient. And the third to say that the default copy assignment operator is sufficient. That way it tells someone looking at the class that you have handled those issues (by leaving the compiler's version to do the jobs). In the case of the copy constructor and assignment operator, it also prevents you from forgetting to add new properties to be copied.