Witam,
Mam klasę macierzy (Mac), która posiada:
Konstruktor kopiujący treści:
Mac::Mac(Mac& m, char* t)
{
if (t) strcpy(Naz, t);
else strcpy(Naz, m.Naz);
this->n = m.n;
P = m.P;
Q = m.Q;
A = new double[n];
for (int i = 0; i < n; i++)
{
A[i] = m.A[i];
}
hasA = m.hasA;
hasN = m.hasN;
}
Poza tym operator rzutowania do double (liczący wyznacznik):
Mac::operator double()const
{
if (P != Q) return 0;
if (P == 1) return A[0];
if (P == 2) return A[0] * A[3] - A[1] * A[2];
double multiplier;
double** minorA = new double*[P - 1];
for (int i = 0; i < P - 1; i++)
{
minorA[i] = new double[Q - 1];
}
double* dividends = new double[Q - 1];
int l;
for (l = 0; l < Q + 1; l++) //l - wybrana kolumna według której rozwijamy
{
if (l == Q) //jeżeli tak jest to znaczy że mamy cały wiersz zer
{
return 0;
}
if (A[l] != 0) //żeby nie dzielić przez 0
{
for (int j = 0; j < l; j++)//przepisanie wszystkich elementów od 0 do kolumny do minora, i do dzielnych
{
dividends[j] = A[j];
for (int k = 0; k < P - 1; k++)
{
minorA[k][j] = A[(k + 1) * P + j];
}
}
for (int j = l; j < Q - 1; j++)//i od kolumny do końca
{
dividends[j] = A[j + 1];
for (int k = 0; k < P - 1; k++)
{
minorA[k][j] = A[(k + 1) * P + j + 1];
}
}
for (int j = 0; j < Q - 1; j++)//robimy zera
{
multiplier = - dividends[j]/ A[l];
for (int k = 0; k < P - 1; k++)
{
minorA[k][j] = minorA[k][j] + A[(k + 1) * P] * multiplier;
}
}
break;
}
}
Mac minor(P - 1, Q - 1, minorA);
return (l % 2 == 0 ? 1 : -1)*(double)minor; //liczymy wyznacznik minora
}
oraz konstruktor konwertujący z double:
Mac::Mac(double a, char* t):Vec(a, t)
{
P = 1;
Q = 1;
}
Jak widać, tak, Mac dziedziczy po klasie Vec (czyli macierz po wektorze). Proszę tego nie komentować, nie ja wymyśliłem tą konstrukcję, jest ona narzucona przez prowadzącego zajęcia. Konstruktor konwertujący bazowy (czyli w Vec) ma taką postać:
Vec::Vec(double a, char *t)
{
//cout << "\nwywolano konstruktor - konwerter\n";
if (t)
{
strcpy(Naz, t);
hasNaz = true;
}
n = 1;
A = new double[n];
A[0] = a;
hasN = true;
hasA = true;
}
Naz - char*, nazwa
A - double*, elementy wektora/macierzy
n - int, liczba elementów wektora/macierzy
P - liczba wierszy macierzy (tylko macierz)
Q - liczba kolumn macierzy (tylko macierz)
hasNaz/N/A - boole, które mi były potrzebne. Nieistotne.
Pytanie: dlaczego, jak mam linijkę:
Mac m4 = Mac(m3, newName);
(m3 już istnieje, jest macierzą, newName - char*, też już istnieje, oba są wypełnione prawidłowo)
Dlaczego, na taką instrukcję kompilator działa w ten sposób że:
a) tworzy mi nową macierz na podstawie innej macierzy, tylko że z inną nazwą ---> to jest w porządku, ale:
b) następnie konwertuje mi tą macierz do double, czyli liczy wyznacznik ---> ?!!!
c) tylko po to, by następnie skonwertować konstruktorem z powrotem do macierzy - macierzy 1x1 o elemencie będącej wyznacznikiem?!
Nie rozumiem. I nie wiem jak zmusić toto do prawidłowego działania.