Non-Templated class from templated class

Write a C++ Program of Non-Templated class derived from Templated base class. Here’s a Simple C++ Program of Non-Templated class derived from Templated base class in C++ Programming Language.

What are Templates in C++ ?

Templates are the foundation of generic programming, which involves writing code in a way that is independent of any particular type.

A template is a blueprint or formula for creating a generic class or a function. The library containers like iterators and algorithms are examples of generic programming and have been developed using template concept.

There is a single definition of each container, such as vector, but we can define many different kinds of vectors for example, vector <int> or vector <string>..

Function Template :

The general form of a template function definition is shown here:

template <class type> ret-type func-name(parameter list)

{
// body of function
}

Class Template :

Just as we can define function templates, we can also define class templates. The general form of a generic class declaration is shown here:

template <class type> class class-name

{
.
.
.
}

Below is the source code for C++ Program of Non-Templated class derived from Templated base class which is successfully compiled and run on Windows System to produce desired output as shown below :

SOURCE CODE : :

/*  C++ Program of Non-Templated class derived from Templated base class  */

#include <iostream>
#include <string>
#include<math.h>

using namespace std;

double M_PI = 3.14;


enum eColor { none = 0, red, white, blue, yellow, green, black };

class Color
{
public:
    Color(eColor color);
    void setColor(eColor color);
    eColor getColor() { return mColor; };
    std::string getStrColor();

protected:
    eColor mColor;
};

Color::Color(eColor _color)
{
   mColor = _color;
}

void Color::setColor(eColor _color)
{
    mColor = _color;
}

std::string Color::getStrColor()
{
    switch(mColor)
    {
       case red:
           return "red";
       case white:
           return "white";
       case blue:
           return "blue";
       case yellow:
           return "yellow";
       case green:
           return "green";
       case black:
           return "black";
       case none:
       default:
           return "none";
    }
}


template <typename T>
class Circle : public Color
{
public:
    Circle(T centerX, T centerY, T radius, eColor color);
    Circle(T centerX, T centerY, T radius);
    Circle(T radius);
    Circle();

    T area();
    T circumference();
    T getX();
    T getY();
    T getRadius();

protected:
    T x;
    T y;
    T radius;
};

template <typename T>
Circle<T>::Circle(T _x, T _y, T _radius, eColor _color)
: Color(_color)
{
    x = _x;
    y = _y;
    radius = _radius;
}

template <typename T>
Circle<T>::Circle(T _x, T _y, T _radius)
: Color(none)
{
    x = _x;
    y = _y;
    radius = _radius;
}

template <typename T>
Circle<T>::Circle(T _radius)
: Color(none)
{
    x = static_cast<T>(0);
    y = static_cast<T>(0);
    radius = _radius;
}

template <typename T>
Circle<T>::Circle()
: Color(none)
{
    x = static_cast<T>(0);
    y = static_cast<T>(0);
    radius = static_cast<T>(1);
}

template <typename T>
T Circle<T>::area()
{
    return M_PI * radius * radius;
}

template <typename T>
T Circle<T>::circumference()
{
    return static_cast<T>(2) * M_PI * radius;
}



class Sphere : public Circle<float>
{
public:
    Sphere(float centerZ, float centerX, float centerY, float radius, eColor color);
    Sphere(float radius);
    Sphere();

    float surfaceArea();
    float volume();
    float getZ();

private:
    float z;
};

Sphere::Sphere(float _x, float _y, float _z, float _radius, eColor _color)
: Circle<float>::Circle (_x, _y, _radius, _color)
{
    this->z = _z;
}

Sphere::Sphere(float _radius)
: Circle::Circle (_radius)
{
    // Defaults from Circle(_radius) constructor can also initialize x, y, z
    this->x = static_cast<float>(0);
    this->y = static_cast<float>(0);
    this->z = static_cast<float>(0);
    this->radius = _radius;
}

Sphere::Sphere()
{
    // Defaults from Circle() default constructor can also initialize values
    this->x = static_cast<float>(0);
    this->y = static_cast<float>(0);
    this->z = static_cast<float>(0);
    this->radius = static_cast<float>(1);
}

float Sphere::surfaceArea()
{
    return static_cast<float>(4) * M_PI * this->radius * this->radius;
}

float Sphere::volume()
{
    float three = 3;
    float four  = 4;
    return four * M_PI * this->radius * this->radius * this->radius / three;
}

int main(int argc, char* argv[])
{
    Sphere sphereA(0.0, 0.0, 0.0,10.0, blue);
    cout << "\nVolume of sphere A :: " << sphereA.volume() << endl;
    cout << "\nColor of sphere A :: "  << sphereA.getStrColor() << endl;
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

/* C++ Program of Non-Templated class derived from Templated base class */

#include <iostream>

#include <string>

#include<math.h>

using namespace std;

double M_PI = 3.14;

enum eColor { none = 0, red, white, blue, yellow, green, black };

class Color

{

public:

Color(eColor color);

void setColor(eColor color);

eColor getColor() { return mColor; };

std::string getStrColor();

protected:

eColor mColor;

};

Color::Color(eColor _color)

{

mColor = _color;

}

void Color::setColor(eColor _color)

{

mColor = _color;

}

std::string Color::getStrColor()

{

switch(mColor)

{

case red:

return "red";

case white:

return "white";

case blue:

return "blue";

case yellow:

return "yellow";

case green:

return "green";

case black:

return "black";

case none:

default:

return "none";

}

template <typename T>

class Circle : public Color

{

public:

Circle(T centerX, T centerY, T radius, eColor color);

Circle(T centerX, T centerY, T radius);

Circle(T radius);

Circle();

T area();

T circumference();

T getX();

T getY();

T getRadius();

protected:

T x;

T y;

T radius;

};

template <typename T>

Circle<T>::Circle(T _x, T _y, T _radius, eColor _color)

: Color(_color)

{

x = _x;

y = _y;

radius = _radius;

}

template <typename T>

Circle<T>::Circle(T _x, T _y, T _radius)

: Color(none)

{

x = _x;

y = _y;

radius = _radius;

}

template <typename T>

Circle<T>::Circle(T _radius)

: Color(none)

{

x = static_cast<T>(0);

y = static_cast<T>(0);

radius = _radius;

}

template <typename T>

Circle<T>::Circle()

: Color(none)

{

x = static_cast<T>(0);

y = static_cast<T>(0);

radius = static_cast<T>(1);

}

template <typename T>

T Circle<T>::area()

{

return M_PI * radius * radius;

}

template <typename T>

T Circle<T>::circumference()

{

return static_cast<T>(2) * M_PI * radius;

}

class Sphere : public Circle<float>

{

public:

Sphere(float centerZ, float centerX, float centerY, float radius, eColor color);

Sphere(float radius);

Sphere();

float surfaceArea();

float volume();

float getZ();

private:

float z;

};

Sphere::Sphere(float _x, float _y, float _z, float _radius, eColor _color)

: Circle<float>::Circle (_x, _y, _radius, _color)

{

this->z = _z;

}

Sphere::Sphere(float _radius)

: Circle::Circle (_radius)

{

// Defaults from Circle(_radius) constructor can also initialize x, y, z

this->x = static_cast<float>(0);

this->y = static_cast<float>(0);

this->z = static_cast<float>(0);

this->radius = _radius;

}

Sphere::Sphere()

{

// Defaults from Circle() default constructor can also initialize values

this->x = static_cast<float>(0);

this->y = static_cast<float>(0);

this->z = static_cast<float>(0);

this->radius = static_cast<float>(1);

}

float Sphere::surfaceArea()

{

return static_cast<float>(4) * M_PI * this->radius * this->radius;

}

float Sphere::volume()

{

float three = 3;

float four = 4;

return four * M_PI * this->radius * this->radius * this->radius / three;

}

int main(int argc, char* argv[])

{

Sphere sphereA(0.0, 0.0, 0.0,10.0, blue);

cout << "\nVolume of sphere A :: " << sphereA.volume() << endl;

cout << "\nColor of sphere A :: " << sphereA.getStrColor() << endl;

return 0;

}

OUTPUT : :

/*  C++ Program of Non-Templated class derived from Templated base class  */

Volume of sphere A :: 4186.67

Color of sphere A :: blue

Process returned 0

/* C++ Program of Non-Templated class derived from Templated base class */

Volume of sphere A :: 4186.67

Color of sphere A :: blue

Process returned 0

Above is the source code and output for C++ Program of Non-Templated class derived from Templated base class which is successfully compiled and run on Windows System to produce desired output.

If you found any error or any queries related to the above program or any questions or reviews , you wanna to ask from us ,you may Contact Us through our contact Page or you can also comment below in the comment section.We will try our best to reach upto you in the short interval.

Thanks for reading the post….

0 0 vote

Article Rating