Plik nagłówkowy:
#ifndef MOJTYP_H_
#define MOJTYP_H_
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
class Vec
{
private:
string nazwa;
int n;
double *V;
static int p;
public:
Vec();
Vec(int n, string nazwa, double *B);
Vec(const Vec &Vec);
~Vec();
Vec & operator=(const Vec& V);
double & operator[](int index)const;
Vec operator+(const Vec &V)const;
Vec operator-(const Vec &V)const;
Vec operator*(const Vec &V)const; //mnozenie przez skalar//
double operator^(const Vec &V)const; //mnozenie skalarne//
friend ostream& operator<< (ostream&,Vec const&);
friend istream& operator>> (istream&,Vec&);
virtual void Wczytaj(istream&);
virtual void Zapisz(ostream&) const;
operator double();
};
#endif
plik źródłowy:
#include "stdafx.h"
#include "vector.h"
#include <iostream>
#include <string>
#include <cstring>
#include <iomanip>
#include <math.h>
using namespace std;
Vec::Vec(){
nazwa="wektor";
n=0;
V= new double[0];
cout<<"Zostal wywolany konstruktor "<<endl;
}
Vec::Vec(int a, string nazw, double *B ){
V=new double[a];
for (int i=0; i<n;i++)
{
V[i]=B[i];
}
nazwa=nazw;
cout<<"Został wywołany konstruktor"<<endl;
}
Vec::Vec(const Vec &Vec){
n=Vec.n;
nazwa=Vec.nazwa;
V=new double[n];
for(int i=0; i<n;i++){
V[i]=Vec.V[i];
}
cout<<"Został wywolany kontruktor kopiujacy"<<endl;
}
Vec::~Vec(){
delete []V;
V=0;
cout<<"Został wywołany destruktor";
}
Vec & Vec::operator=(const Vec &A)
{
cout<<"zostal wywolany operator przypisania";
if(&A==this) return *this;
delete [] V;
nazwa=A.nazwa;
V=new double[n];
for(int i=0; i<n;i++){
V[i]=A.V[i];
}
return *this;
}
double & Vec:: operator[](int index)const
{
cout<<"Zostal wywołany operator indeksacji"<<endl;
if(index >= 0 && index < n)
return V[index];
}
Vec Vec:: operator+(const Vec &A)const
{
cout<<"Zostal wywolany operator dodawania";
int ilosc;
if (n >= A.n)
ilosc = n;
else
ilosc = A.n;
double * wynik = new double[ilosc];
if ( n >= A.n)
{
for (int i = 0; i < A.n; i++)
wynik[i] = A.V[i] + V[i];
for (int j = A.n; j < n; j++)
wynik[j] = V[j];
}
else
{
for (int i = 0; i < n; i++)
wynik[i] = A.V[i] + V[i];
for (int j = n; j < A.n; j++)
wynik[j] = A.V[j];
}
Vec * suma = new Vec(ilosc, "sum", wynik);
return *suma;
}
Vec Vec::operator - (const Vec& A)const
{
cout<<"Zostałwywolany operator odejmowania";
int ilosc;
if (n >= A.n)
ilosc = n;
else
ilosc = A.n;
double * wynik = new double[ilosc];
if (n >= A.n)
{
for (int i = 0; i < A.n; i++)
wynik[i] = V[i] - A.V[i];
for (int j = A.n; j < n; j++)
wynik[j] =V[j];
}
else
{
for (int i = 0; i < n; i++)
wynik[i] = V[i] - A.V[i];
for (int j = n; j < A.n; j++)
wynik[j] = -A.V[j];
}
Vec * roznica = new Vec(ilosc, "Roz", wynik);
return *roznica;
}
double Vec::operator^ (const Vec& A)const
{
cout<<"Zostal wywolany operator mnozenia skalarnego";
double wynik = 0;
int x; // zmienna pomocnicza zawierajace liczbe elementow krotszego wektora
if(n > A.n) x = A.n;
else x = this->n;
for(int i=0; i<x; i++) // sumowanie iloczynow wspolrzednych
wynik += V[i] * A.V[i];
return wynik;
}
istream &operator >> (istream& wejscie, Vec& A)
{
A.Wczytaj(wejscie);
return wejscie;
}
ostream &operator << (ostream& wyjscie, const Vec& A)
{
A.Zapisz(wyjscie);
return wyjscie;
}
int Vec::p = 0;
void Vec::Zapisz(ostream& wyjscie) const
{
int n = wyjscie.precision(this->p);
wyjscie << fixed << "Wektor " << this->nazwa << "[ ";
if (this->V)
wyjscie << ' ' << this->V[0];
for (int i=1; i < this->n; i++)
wyjscie << ", " << this->V[i];
wyjscie << " ]" << endl << setprecision(n);
}
void Vec::Wczytaj(istream& wejscie)
{
wejscie >> nazwa;
nazwa = '\0';
wejscie >> n;
delete [] V;
V = new double [n];
for (int i = 0; i < n; i++)
wejscie >> V[i];
}
Vec::operator double()
{
double wynik = 0.0;
for(int i = 0 ; i < n; i++)
wynik += V[i]*V[i];
return sqrt(wynik);
}
Vec Vec::operator*(const Vec &A)const
{
cout<<"Został wywołany operator mnożenia przez skalar";
int d=5;
double *wynik=new double[n];
for(int i=0; i<n;i++){
wynik[i]=A[i]*d;
}
Vec * skalar= new Vec(n, "skal", wynik);
return *skalar;
}
main:
#include "stdafx.h"
#include <iostream>
#include "vector.h"
int _tmain(int argc, _TCHAR* argv[])
{
int n,p,a;
double *A,*B;
string nazwa,nazwa2;
cout<<"Podaj precyzje wektorow"<<endl;
cin>>p;
cout<<"Oto, kalkulator wektorowy, proszę podać rozmiar obu wektorow"<<endl;
cin>>n;
A= new double[n];
B= new double[n];
cout<<"Jak chcesz nazwac wektor ?"<<endl;
cin>>nazwa;
Vec V1(n,nazwa,A);
cout<<"Podaj wartosci pierwszego wektora"<<endl;
for(int i=0;i<n;i++){
cin>>A[i];
}
cout<<"Jak chcesz nazwac drugi wektor ?"<<endl;
cin>>nazwa2;
Vec V2(n,nazwa2,B);
cout<<"Podaj wartosci drugiego wektora"<<endl;
for(int i=0;i<n;i++){
cin>>B[i];
}
do{
cout<<"#####################################"<<endl;
cout<<"############### MENU ################"<<endl;
cout<<"#####################################"<<endl;
cout<<"Co chcesz zrobic ? "<<endl;
cout<<"1. Dodac wektor pierwszy do drugiego"<<endl;
cout<<"2. Odjac jeden wektor od drugiego"<<endl;
cout<<"3. Pomnozyc skalarnie jeden wektor przez drugi"<<endl;
cout<<"4. Pomnozyc jeden wektor razy skalar"<<endl;
cout<<"5. Koniec programu"<<endl;
cin>>a;
switch(a)
{
case 1 :
cout<<"Wynik to "<<(V1+V2);break;
case 2:
cout<<"wynik to "<<(V1-V2);break;
case 3:
cout<<"wynik to "<<(V1^V2);break;
case 4:
cout<<"Podaj wartosc skalaru";
int d;
cin>>d;
cout<<"Wynik pomnozenia pierwszego wektora przez skalar, to "<<(V1*d);
cout<<"Wynik pomnozenia drugiego wektora przez skalar, to "<<(V2*d); break;
default: return 0;
}
}while(a<5);
system ("pause");
}
To tak, wszystko działa dobrze do momentu wywołania którejś z opcji. Przy czym dwie pierwsze zawieszają program, reszta w wyniku wyrzuca 0 za każdym razem.