Program ciagi - metematyka

Witam potrzebuje analizy kodu. Co dodac co ujac. Wszytskie uwagi mile widzane. Pozdro

/------------------------------------- PLIK PIERWSZY Ciag.cpp -------------------------------------------------/

#ifndef CIAG
#define CIAG
#include <iostream>

using std::ostream;

class Ciag
{
private:
enum { MAX = 10}; //ilosc elementow ciagu
double tablica[MAX]; //elementy ciagu
double pierwszy_wyraz; //pierwszy element
public:
Ciag(); //konstruktor domyslny
Ciag(double pierwszy); //konstruktor
void operator+(double r); //przeciazony operator + dla ciagu arytmetycznego
void operator*(double r); //przeciazony operator * dla ciagu geometrycznego
double Operacja(int ile); //Suma pocztkowych ile wyrazow
friend ostream & operator<<(ostream & os,const Ciag & c);
}; //koniec klasy

#endif

/ ---------------------------------------- PLIK DRUGI Ciag.cpp----------------------------------------------------/

#include "Ciag.cpp"

Ciag::Ciag() //konstruktor domyslny
{
pierwszy_wyraz = 0;

}

Ciag::Ciag(double pierwszy) //konstruktor
{
pierwszy_wyraz = pierwszy;
}

void Ciag::operator+(double r) //przeciazony operator + dla ciagu arytmetycznego
{
tablica[0] = pierwszy_wyraz;
for(int i = 1; i <= MAX; i++)
tablica[i] = tablica[i - 1] + r;
}

void Ciag::operator*(double r) //przeciazony operator * dla ciagu geometrycznego
{

 tablica[0] = pierwszy_wyraz;
 for(int i = 1; i <= MAX; i++)
  tablica[i] = tablica[i - 1] * r;

}

/----------------------------------- PLIK TRZECI Ciag3.cpp -----------------------------------------------------/

#include "Ciag.cpp"
#include <iostream>

int main(int argc, char *argv[])
{
Ciag wybrany(2); // ciag okreslany pierwszym wyrazem
wybrany * 3; //tutaj wystarczy zmienic operator + albo *
std::cout << wybrany;
system("PAUSE");
return EXIT_SUCCESS;
}

I jeszcze dwie funkcje :

double Ciag::Operacja(int ile) //Suma poczatkowych ile wyrazow
{
double Suma;
if(ile <= MAX)
for(int i = 0; i < ile; i++)
Suma += tablica[i];
else
std::cout << "Nie poprawna dana. " <<std::endl;
return Suma;
}

ostream & operator<<(ostream & os, const Ciag & c)
{
for(int i = 0; i < Ciag::MAX; i++)
os << c.tablica[i] << ", ";

    return os;

}

A jakie jest zadanie?
Nie widzę powodu obliczenia wszystkich tych elementów, ponieważ istnieje bardzo proste równanie obliczające N-ty element takiego ciągu.

Drugi program wyglada tak:

#include <iostream>

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

const int MAX = 5;//rozmiar tablicy

void Geometryczny(double *, const int, double, double); //ciag geometryczny
void Arytmetyczny(double *, const int, double, double); //ciag arytmetyczny
double SumaWyrazow(double *, double, double); //Suma n poczatkowych wyrazow
void Pokaz(double *, const int); //wyswietla ciag

• ---------------------------- FUNKCJA MAIN -----------------------------------*
  int main()
  {
  double tab[MAX]; //tablica
  Geometryczny(tab, MAX, 0.2 , 3);//funkcja geometryczna
  cout << endl;
  Arytmetyczny(tab, MAX, 3, 5); //funkcja arytmetyczna

  cin.ignore();
  cin.get();
  return 0;
  }
  ------------------------------ KONIEC MAIN --------------------------------------

void Pokaz(double * t, const int n) //wyswietla ciag
{
for(int i = 0; i < n; i++)
cout << t[i] << ", ";
}

double SumaWyrazow(double * tablica, int n) //Suma n poczatkowych wyrazow
{
if(n > MAX)
{
cout << "Tablica ma maxymalnie " << MAX << " wyrazow, Ty podales wiecej"
<< "Obcinam zakres do " <<MAX<< endl;
n = MAX;
}

   double Suma;               //zmienna Suma przechowuje sume n poczatkowych wyrazow
   for(int i = 0; i < n; i++)
    Suma += tablica[i];       //dodaje kolejne elemanty tablicy
    
   return Suma;              // zwraca sume

}

void Geometryczny(double * tablica, const int rozmiar, double roznica, double pierwszy_wyraz) //ciag geometryczny
{
cout << "Ciag geometryczny " <<endl;
tablica[0] = pierwszy_wyraz; //pierwszy wyraz
for(int i = 1; i <= rozmiar; i++)
tablica[i] = tablica[i - 1] * roznica; //uzupelnia tablice kolejnymi wyrazami
Pokaz(tablica, rozmiar); //wyswietla ciag geometryczny
cout << endl;
double Suma = SumaWyrazow(tablica,3); //suma n poczatkowych wyrazow
cout << "Suma wyrazow : "<< Suma << endl; //wyswietla sume n poczatkowych wyrazow
}

void Arytmetyczny(double * tablica, const int rozmiar, double roznica, double pierwszy_wyraz) //ciag arytmetyczny
{
cout << "Ciag arytmetyczny " <<endl;
tablica[0] = pierwszy_wyraz; //pierwszy wyraz
for(int i = 1; i <= rozmiar; i++)
tablica[i] = tablica[i - 1] + roznica; //uzupelnia tablice kolejnymi wyrazami
Pokaz(tablica, rozmiar); //wyswietla ciag arytmetyczny
cout << endl;
double Suma = SumaWyrazow(tablica, 4); //suma n poczatkowych wyrazow
cout << "Suma wyrazow : "<< Suma << endl; //wyswietla sume n poczatkowych wyrazow
}

To się nada:

double NtyArytmetyczny(double a0,double r,size_t n) { return a0+r*n; }
double NtyGeometryczny(double a0,double q,size_t n) { return a0*pow(q,n); }
double SumaArytmetyczny(double a0,double r,size_t n) { return 0.5*(a0+a0+r*n)*(n+1); }
double SumaGeometryczny(double a0,double q,size_t n) { return a0*(1-pow(q,n+1))(1-q); }

Jak masz coś więcej to są to jakieś dewiacje, no chyba że zadanie jakoś specjalnie brzmi.

Sugeruję, na podstawie powyższego postu @_13th_Dragon (czytać kodu mi się nie chce), zaznajomić się z podstawowymi wzorami ciągów. Ułatwią Ci życie i skrócą kod.
Kilka stron odnośnie ciągów:
Ogólnie o ciągach by Wikipedia
Ciąg geometryczny lub jeżeli lubisz wersję naukową Wikipedii
Ciąg arytmetyczny lub jeżeli lubisz wersję naukową Wikipedii

No i najważniejsze, czy program ma być pomocą przy zadaniach z ciągów(lenistwo liczenia na piechotę) czy konkretnie pod jakieś wymyślne zdanie ?

Dobra, spróbuje tak bez ironii i przenośni, odpowiedzieć na twoje pytanie. A więc twój kod działa, ale są uwagi (do obu przykładów):
Żaden dobry programista nie zrobi w ten sposób tych zadań, ponieważ da się prościej, szybciej, taniej, wygodniej, czytelniej stworzyć kod szybszy i zabierający mniej pamięci. Więc ta implementacja świadczy jedynie o słabych umiejętnościach(a w zasadzie ich braku) programowania. Również nie umiejętności łączenia wiedzy z zakresu różnych dziedzin(chociaż tutaj nie problem to zrobić). Zaimplementowanie takiego czegoś jest nie do przyjęcia, przez kierownika projektu, ponieważ jest to nieoptymalne. Jeśli ktoś takie coś implementuje widać, że idzie w złym kierunku, bo kod programisty musi być optymalny, nie tylko działać. P.S. Zawsze uważałem, że ścisłowiec powinien szukać drogi na skróty, bo świadczy to o myśleniu, a po tym kodzie widać raczej jego brak. Zamiast pomyśleć, od razu ktoś wziął się do pisania tego rozbijając zadanie na pomniejsze kroki.