Создать базовый класс Triad и производный класс vector3D

#include <iostream>
#include <string>
using namespace std;
 
 
class vector3D {
public:
    int a;
    int b;
    int c;
 
    vector3D(int inita = 0, int initb = 0, int initc = 0) : a(inita), b(initb), c(initc) {};
 
        // сложение векторов
    vector3D operator+(vector3D v2) {
        vector3D vec;
        vec.a = a + v2.a;
        vec.b = b + v2.b;
        vec.c = c + v2.c;
        return vec;
    }
        // произведение векторов
    vector3D operator*(vector3D v2) {
        vector3D vec;
        vec.a = a*v2.a;
        vec.b = b*v2.b;
        vec.c = c*v2.c;
        return vec;
    }
 
 
    void show() {
        cout << a << "," << b << "," << c;
    }
 
};
 
 
 
int main()
{
    setlocale(LC_ALL, "rus");
    int x1, y1, z1, x2, y2, z2;
    cout << "Координаты первого вектора: "; cin >> x1 >> y1 >> z1;
    cout << "Координаты второго вектора: "; cin >> x2 >> y2 >> z2;
 
    vector3D v1(x1, y1, z1);
    vector3D v2(x2, y2, z2);
 
    (v1 + v2).show();
    cout << endl;
    (v1*v2).show();
    cout << endl;
    system("pause");
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
 
class Triad {
public:
    double C1;
    double C2;
    double C3;
    double D1;
    double D2;
    double D3;
 
 
    void Read1()
    {
        cout << "Ввод первой тройки чисел: "; cin >> C1 >> C2 >> C3;
    }
 
    void Read2()
    {
        cout << "Ввод второй тройки чисел: "; cin >> D1 >> D2 >> D3;
    }
 
    double Summa1(double R)
    {
        return C1 + R;
    }
 
    double Summa2(double R)
    {
        return C2 + R;
    }
 
    double Summa3(double R)
    {
        return C3 + R;
    }
 
    double Proizv1(double R)
    {
        return C1 * R;
    }
 
    double Proizv2(double R)
    {
        return C2 * R;
    }
    double Proizv3(double R)
    {
        return C3 * R;
    }
 
    bool Init()
    {
        if (C1 == D1 && C2 == D2 && C3 == D3) return 0;
        else return 1;
    }
 
    void Display(double R)
    {
        cout << "Сумма: " << Summa1(R) << " " << Summa2(R) << " " << Summa3(R) << endl;
        cout << "Произведение: " << Proizv1(R) << " " << Proizv2(R) << " " << Proizv3(R) << endl;
        if (Init()) cout << "Пара троек чисел не равна" << endl;
        else cout << "Пара троек чисел равна" << endl;
    }
 
};
 
class vector3D {
public:
    double a;
    double b;
    double c;
 
    vector3D(double inita = 0, double initb = 0, double initc = 0) : a(inita), b(initb), c(initc) {};
 
    vector3D operator+(vector3D v2) {
        vector3D vec;
        vec.a = a + v2.a;
        vec.b = b + v2.b;
        vec.c = c + v2.c;
        return vec;
    }
 
    vector3D operator*(vector3D v2) {
        vector3D vec;
        vec.a = a*v2.a;
        vec.b = b*v2.b;
        vec.c = c*v2.c;
        return vec;
    }
 
 
    void show() {
        cout << a << "," << b << "," << c;
    }
 
};
 
 
 
int main()
{
    setlocale(LC_ALL, "rus");
    double R;
    char wish;
    double x1, y1, z1, x2, y2, z2;
    // Triad
    do
    {
        Triad operations;
        operations.Read1();
        double R;
        
        cout << "Введите число, с которым будут осуществляться операции: "; cin >> R;
        operations.Read2();
        operations.Display(R);
        cout << "Если вы хотите ввести новые данные, нажмите y/Y, если нет, нажмите n/N: "; cin >> wish;
 
    } while (wish == 'Y' || wish == 'y' || wish == 'н' || wish == 'Н');
    
    // Vector3D
    do
    {
        cout << "Ввод координат первого вектора: "; cin >> x1 >> y1 >> z1;
        cout << "Ввод координат второго вектора: "; cin >> x2 >> y2 >> z2;
 
        vector3D v1(x1, y1, z1);
        vector3D v2(x2, y2, z2);
 
        cout << "Сложение: " << endl;
        (v1 + v2).show();
        cout << endl;
        cout << "Произведение: " << endl;
        (v1*v2).show();
        cout << endl;
        cout << "Если вы хотите ввести новые данные, нажмите y/Y, если нет, нажмите n/N: "; cin >> wish;
    }while (wish == 'Y' || wish == 'y' || wish == 'н' || wish == 'Н');
    
    system("pause");
    return 0;
}

class Triad
{
    int a;
    int b;
    int c;
 
public:
    // здесь конструктор и операции
};
 
class vector3D: public Triad
{
public:
    // здесь сложение и скалярное произведение
};

#include <iostream>
#include <string>
using namespace std;
 
 
class Triad {
 
    double C1;
    double C2;
    double C3;
 
public:
 
    void Read()
    {
        cout << "Ввод тройки чисел: "; cin >> C1 >> C2 >> C3;
    }
 
 
    double Summa1(double R)
    {
        return C1 + R;
    }
 
    double Summa2(double R)
    {
        return C2 + R;
    }
 
    double Summa3(double R)
    {
        return C3 + R;
    }
 
    double Proizv1(double R)
    {
        return C1 * R;
    }
 
    double Proizv2(double R)
    {
        return C2 * R;
    }
    double Proizv3(double R)
    {
        return C3 * R;
    }
 
    bool Init(double D1, double D2, double D3)
    {
        if (C1 == D1 && C2 == D2 && C3 == D3) return 0;
        else return 1;
    }
 
    void Display(double R, double D1, double D2, double D3)
    {
        cout << "Сумма: " << Summa1(R) << " " << Summa2(R) << " " << Summa3(R) << endl;
        cout << "Произведение: " << Proizv1(R) << " " << Proizv2(R) << " " << Proizv3(R) << endl;
        if (Init(D1, D2, D3)) cout << "Пара троек чисел не равна" << endl;
        else cout << "Пара троек чисел равна" << endl;
    }
 
};
      ....
int main()
{
    setlocale(LC_ALL, "rus");
    double R, D1, D2, D3;
    char wish;
    double x1, y1, z1, x2, y2, z2;
    // Triad
    do
    {
        Triad operations;
        operations.Read();
        double R;
        cout << "Введите число, с которым будут осуществляться операции: "; cin >> R;
        cout << "Введите тройку чисел с которой будет проверено равенство: "; cin >> D1 >> D2 >> D3; // Вторая тройка для проверки на равенство ???
        operations.Display(R, D1, D2, D3);
        cout << "Если вы хотите ввести новые данные, нажмите y/Y, если нет, нажмите n/N: "; cin >> wish;
 
    } while (wish == 'Y' || wish == 'y' || wish == 'н' || wish == 'Н');
         .....
        system("pause");
    return 0;
}

    Triad & operator += (double R)
    {
        C1 += R;
        C2 += R;
        C3 += R;
        return *this;
    }

Triad() {
        cout << "Ввод тройки чисел: "; cin >> C1 >> C2 >> C3;
    }

/***
*
*   Copyright (c) 1999, Valve LLC. All rights reserved.
*   
*   This product contains software technology licensed from Id 
*   Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
*   All Rights Reserved.
*
*   Use, distribution, and modification of this source code and/or resulting
*   object code is restricted to non-commercial enhancements to products from
*   Valve LLC.  All other use, distribution, or modification is prohibited
*   without written permission from Valve LLC.
*
****/
//  Vector.h
// A subset of the extdll.h in the project HL Entity DLL
//
 
#if !defined FILE_UTIL_VECTOR_H
#define FILE_UTIL_VECTOR_H
 
// Misc C-runtime library headers
#include "STDIO.H"
#include "STDLIB.H"
#include "MATH.H"
 
// Header file containing definition of globalvars_t and entvars_t
typedef int func_t;                 //
typedef int string_t;               // from engine's pr_comp.h;
typedef float vec_t;                // needed before including progdefs.h
 
//=========================================================
// 2DVector - used for many pathfinding and many other 
// operations that are treated as planar rather than 3d.
//=========================================================
class Vector2D
{
public:
    inline Vector2D(void)                                   { }
    inline Vector2D(float X, float Y)                       { x = X; y = Y; }
    inline Vector2D operator+(const Vector2D& v)    const   { return Vector2D(x+v.x, y+v.y);    }
    inline Vector2D operator-(const Vector2D& v)    const   { return Vector2D(x-v.x, y-v.y);    }
    inline Vector2D operator*(float fl)             const   { return Vector2D(x*fl, y*fl);  }
    inline Vector2D operator/(float fl)             const   { return Vector2D(x/fl, y/fl);  }
    
    inline float Length(void)                       const   { return (float)sqrt(x*x + y*y );       }
 
    inline Vector2D Normalize ( void ) const
    {
        Vector2D vec2;
 
        float flLen = Length();
        if ( flLen == 0 )
        {
            return Vector2D( (float)0, (float)0 );
        }
        else
        {
            flLen = 1 / flLen;
            return Vector2D( x * flLen, y * flLen );
        }
    }
 
    vec_t   x, y;
};
 
inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
inline Vector2D operator*(float fl, const Vector2D& v)  { return v * fl; }
 
//=========================================================
// 3D Vector
//=========================================================
class Vector                        // same data-layout as engine's vec3_t,
{                               //      which is a vec_t[3]
public:
    // Construction/destruction
    inline Vector(void)                             { }
    inline Vector(float X, float Y, float Z)        { x = X; y = Y; z = Z;                      }
    inline Vector(double X, double Y, double Z)     { x = (float)X; y = (float)Y; z = (float)Z; }
    inline Vector(int X, int Y, int Z)              { x = (float)X; y = (float)Y; z = (float)Z; }
    inline Vector(const Vector& v)                  { x = v.x; y = v.y; z = v.z;                } 
    inline Vector(float rgfl[3])                    { x = rgfl[0]; y = rgfl[1]; z = rgfl[2];    }
 
    // Operators
    inline Vector operator-(void) const             { return Vector(-x,-y,-z);              }
    inline int operator==(const Vector& v) const    { return x==v.x && y==v.y && z==v.z;    }
    inline int operator!=(const Vector& v) const    { return !(*this==v);                   }
    inline Vector operator+(const Vector& v) const  { return Vector(x+v.x, y+v.y, z+v.z);   }
    inline Vector operator-(const Vector& v) const  { return Vector(x-v.x, y-v.y, z-v.z);   }
    inline Vector operator*(float fl) const         { return Vector(x*fl, y*fl, z*fl);      }
    inline Vector operator/(float fl) const         { return Vector(x/fl, y/fl, z/fl);      }
    
    // Methods
    inline void CopyToArray(float* rgfl) const      { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
    inline float Length(void) const                 { return (float)sqrt(x*x + y*y + z*z); }
    operator float *()                              { return &x; } // Vectors will now automatically convert to float * when needed
    operator const float *() const                  { return &x; } // Vectors will now automatically convert to float * when needed
    inline Vector Normalize(void) const
    {
        float flLen = Length();
        if (flLen == 0) return Vector(0,0,1); // ????
        flLen = 1 / flLen;
        return Vector(x * flLen, y * flLen, z * flLen);
    }
 
    inline Vector2D Make2D ( void ) const
    {
        Vector2D    Vec2;
 
        Vec2.x = x;
        Vec2.y = y;
 
        return Vec2;
    }
    inline float Length2D(void) const                   { return (float)sqrt(x*x + y*y); }
 
    // Members
    vec_t x, y, z;
};
inline Vector operator*(float fl, const Vector& v)  { return v * fl; }
inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }
 
#define vec3_t Vector
 
 
#define VectorAdd(a,b,c) {(c)[0]=(a)[0]+(b)[0];(c)[1]=(a)[1]+(b)[1];(c)[2]=(a)[2]+(b)[2];}
#define VectorCopy(a,b) {(b)[0]=(a)[0];(b)[1]=(a)[1];(b)[2]=(a)[2];}
#define VectorClear(a) { a[0]=0.0;a[1]=0.0;a[2]=0.0;}
 
#endif