Програмирование на C++

[gepar]

Продолжаю покорение потоков. На этот раз непонятно почему второй раз ввод в поток происходить не будет:

Код: [Выделить]

int main()
{
    char a[10];
    cin.get(a,10,'.');
    cout<<a<<endl;
    cin.getline(a,10,'.');
    cout<<a<<endl;
    cout<<"WHY?";
}Тоесть я печатаю символы (10 штук либо ограничиваю их точкой), они печатаются 1 раз, происходит перевод каретки 1 раз, потом второй и печатается текст в конце. Почему так? И почему если поменять местами getline и get то будет два раза считывание в поток как изначально и хотелось мне. Хотя я вообще это сделал потому что Дейтел пишет мол через get ограничивающий символ отбрасываться не должен был, но что-то это нифига не так  

Добавлено позже:
Заодно пока повторял потоки заметил что то чем не пользовался и выучил вначале я уже и забыл (setw, setfill) и никак не мог вспомнить какие же там были манипуляторы потока эти, помнил что можно так, помнил какие аргументы, но не мог вспомнить слова.

Добавлено позже:
И ещё очему вот так

Код: [Выделить]

    cout<<setw(8)<<setprecision(3)<<1024.98765;идёт печать в научном стиле? Я ведь всего-то хотел чтобы после запятой было 3 цифры, а оно мне выдало тут
1.02e+003
Или это в зависимости от компилятора?

Добавлено позже:
И вопрос N3: у меня тут курсовая по созданию класса "Матрица", думаю понятно что он будет делать, так вот я делал что-то подобное где в реализации у меня был одномерный массив, HoRRoR, как думаешь стоит ли переделывать с реализацией в виде массива массивов (угу, указателя на указатель) ради того чтобы вид был получше (в реализации в виде одномерного массива идёт высчитывание же сколько надо выделить ячеек в одномерном массиве чтобы реализовать матрицу ну и во всех операциях я тогда делал те или иные операции чтобы работало это всё как двухмерный массив (ведь матрица двухмерный массив же)) или вид с этими двойными указателями будет ещё хуже чем с доп. расчётами? Я собственно хочу добиться того чтобы код выглядел максимум красиво, а в той моей реализации по сути есть костыли же в виде перерасчётов. Балл за курсовую то в диплом пойдёт ну и на стипендию влиять будет так что конечно же хотелось бы 5 

[HoRRoR]

http://www.cplusplus.com/reference/iostream/istream/get/

If the delimiting character is found, it is not extracted from the input sequence and remains as the next character to be extracted. Use getline if you want this character to be extracted (and discarded).

http://www.cplusplus.com/reference/iostream/istream/getline/

If the delimiter is found, it is extracted and discarded, i.e. it is not stored and the next input operation will begin after it.

Т.е. пишем "abc.def" - у нас с помощью get читается "abc", остаётся ".def".
Читаем далее с помощью getline - получаем пустую строку (т.к. сразу же следует символ конца), в потоке остаётся "def" ('.' отбрасывается).
Всё очевидно.

И ещё очему вот так идёт печать в научном стиле? Я ведь всего-то хотел чтобы после запятой было 3 цифры, а оно мне выдало тут
1.02e+003

http://www.cplusplus.com/reference/iostream/manipulators/scientific/
http://www.cplusplus.com/reference/iostream/manipulators/fixed/

Код: [Выделить]

    cout<<setw(8)<<fixed<<setprecision(3)<<1024.98765;


И вопрос N3: у меня тут курсовая по созданию класса "Матрица", думаю понятно что он будет делать, так вот я делал что-то подобное где в реализации у меня был одномерный массив, HoRRoR, как думаешь стоит ли переделывать с реализацией в виде массива массивов (угу, указателя на указатель) ради того чтобы вид был получше (в реализации в виде одномерного массива идёт высчитывание же сколько надо выделить ячеек в одномерном массиве чтобы реализовать матрицу ну и во всех операциях я тогда делал те или иные операции чтобы работало это всё как двухмерный массив (ведь матрица двухмерный массив же)) или вид с этими двойными указателями будет ещё хуже чем с доп. расчётами? Я собственно хочу добиться того чтобы код выглядел максимум красиво, а в той моей реализации по сути есть костыли же в виде перерасчётов. Балл за курсовую то в диплом пойдёт ну и на стипендию влиять будет так что конечно же хотелось бы 5

Я бы хранил в одномерном массиве. Если данных не много или много динамики, то можешь и двумерный сделать. А для красоты можно перегрузить операторы, хоть и не совсем практично будет:

Код: [Выделить]

class Matrix
{
private:
    vector<int> a;
    class Op
    {
        friend class Matrix;
        int row;
        Matrix& mat;
        Op(Matrix &m):mat(m)
        {
        }
    public:
        int& operator [](int j)
        {
            return mat.at(row, j);
        }
    } op;
public:
    int& at(int i, int j)
    {
        return a[j * 10 + i];
    }
    Op& operator [](int i)
    {
        op.row = i;
        return op;
    }
    Matrix():a(10*10), op(*this)
    {
    }
};
Как видишь, хренотень неимоверная)

[gepar]

Посмотрел на свой старый класс и решил что наверное с нуля будет проще написать всё же курсовую эту, мне ещё повезло что у меня тема курсовой матрица, у некоторых надо создать в борланде класс Кисточка, чтобы им можно было рисовать фигурки и потом делать их заливку разными цветами и всё это работало под DOS.
В общем я тут подумал-подумал и вижу что смысла делать шаблонной её (матрицу) нет, а можно делать просто в реализации указатель на double (или нет?) да и всё. В общем-то набросок в виде .h файла, если есть предложения, комментарии в виде конструктивной критики то пишите, сам рабочий класс уже буду завтра доделывать или даже более вероятно послезавтра.

Код: [Выделить]

# ifndef MATRIX_H
# define MATRIX_H

class Matrix
{
friend ostream &operator<<(ostream &output, Matrix &);
friend istream &operator>>(istream &input, Matrix &); // Пока не знаю какой придумать ввод матрицы
public:
    Matrix(int, int);    //конструктор с указанием количества столбцов и строк
    Matrix(int, int, double)  //конструктор с указанием количества столбцов и строк
                         //а также элемента которым будет инициализирована матрица
    Matrix (const Matrix &); // конструктор копии
    double det(); // детерминант матрицы
    Matrix inverse(const Matrix); // возвращает инвертированную матрицу
    double &operator()(int a, int b); //возвращает запрошенный элемент
    double &operator()(int a, int b) const;
    Matrix &transposed(const Matrix); // транспонирование матрицы
    Matrix &operator*(const double); // возвращает матрицу умноженную на число
    Matrix &operator*(const Matrix, const Matrix); //возвращает матрицу умноженную на другую матрицу
    Matrix &operatro/(const Matrix, const Matrix); //деление матрицы на матрицу, будет через реализовано через функцию умножения матриц
    Matrix &operator+(const Matrix, const Matrix); //возвращает сумму матриц
    Matrix &operator-(const Matrix, const Matrix); //возвращает разницу матриц



private:
    bool isCorrect(Matrix,Matrix); // проверка что матрицы совместимы, понадобиться для * и прочих мат.операций с двумя матрицами
    int row; //количество строк
    int column; //количество столбцов
    double *ptr; //указатель на данные самой матрицы
};

#endif
Пока решил что данные будет просто указатель , ну а потом в конструкторе будет что-то вроде ptr= new double [row*column+1].

[gepar]

По ходу дела ещё хотел спросить:
часть курсовых заданий идут по типу "Сделать класс полигон. Полигоны - разноцветные многоугольники на экране , закрашенный и с заранее неизвестным количеством узлов. Узлы можно редактировать. Полигон этот должен быть как динамический двунаправленный список. Работать это должно в граф. режиме VGA 640x480x16 и сделано это должно быть для MS DOS".  Ну и есть ещё задания где сделать программу чтобы можно было создавать "окна", ну тоесть графическую всякую ерунду. Я так понимаю это задания с расчётом на borland c++ с его специфическими графическими библиотеками? Если да то насколько сложно сделать такой вот класс полигон например?
Иными словами используя какие классы или ещё что (я так понимаю из состава borland c) делают вот такие вот программы с графикой под DOS?/b]
P.S Хорошо что у меня курсовое задание находится в той части списка где нет вот этого всего по типу нарисуйте калькулятор, сделайте аналог paint, сделайте класс полигон и т.д  

[HoRRoR]

Я так понимаю это задания с расчётом на borland c++ с его специфическими графическими библиотеками? Если да то насколько сложно сделать такой вот класс полигон например?

Хз, в задании не сказано, значит делай как хочешь. А сделать класс - легко. std::list уже даёт тебе готовый двусвязный список, так что разберись с итераторами и используй его как основу.
Вот отрисовка - уже другое дело. На OpenGL, например, отрисовать такой полигон - проще простого. Если у борланда тоже есть готовые решение - то хорошо. Иначе - придётся тебе с геометрией работать.

[gepar]

HoRRoR,так вот отрисовка меня и волнует в первую очередь, сделанное с использованием OpenGL ведь не заведётся под dos, да? А вообще с OpenGL работать сложно? Я до этого граф. интерфейс в программах только в делфи делал и то немного, буквально штук 5-10, там всё просто было.

Добавлено позже:
Вообще конкретно это задание делать не надо, это вообще курсовые моих одногрупников там есть и сделать аналог paint'а чтобы можно было рисовать и делать заливку разными цветами, рисовать надо чтобы можно было и мышкой и кнопками направления с клавы и это всё тоже под DOS. Но такую курсовую однокурсник уже где-то оплатил (заплатил кстати 500 грн что будет под 2 000 русских рублей) так я вот и задумался насколько это сложно, так я в принципе вроде когда читаю задания то могу сделать что там написано, но всё кроме графики. Вот и думаю лезть в дебри этой графики под DOS и ускоренно учить её или это бесполезное дело и так быстро всё не получиться выучить  Я вообще с борландовской график.х работал только на уровне нарисовать пару геом. фигур да подвигать их да поудалять, в общем там всё было уровня "белые полосы на чёрном фоне".

[HoRRoR]

Про OpenGL под DOS забудь. Он не сложный, но поначалу таким кажется, пока не освоишься.
Вообще, самый простой алгоритм отрисовки, который приходит на ум: отрисовывать по треугольнику.
Вот есть координаты полигона: a, b, c, d, e, f. Рисуешь треугольники: abc, bcd, cde, def, efa, fab. Уж как нарисовать треугольник ты сообразишь, должны быть какие-то графические библиотеки под DOS. Единственно что - как бы зазоров не было между треугольниками, такое бывает... Даже в SVG сталкивался, ужас.

[gepar]

Внезапно определил что детерминант то посчитать не так то просто когда матрица может быть n размера, ни у кого наработок не завалялось? 

Добавлено позже:
Хотя вот чего-то нашёл, надо теперь проверить.

Код: [Выделить]

double Matrix::det() const
{
    Matrix copy(*this);        // Копия исходной матрицы
    double result = 1.0;       // Результат
    unsigned dim = copy._rows; // Размерность матрицы
    int sign = 1;              // Знак определителя
    bool key = true;           // Вспомогательная переменная - индикатор,
                               // была ли найдена строка с ненулевым элементом
                               // в k-ом столбце

    // Дальнейшие действия выполняются, только если
    // исходная матрица - квадратная
    if (copy._rows == copy._cols)
    {
        // Проходим по строкам матрицы (назовём их исходными)
        for (unsigned k = 0; k < dim; ++k)
        {
            // Если элемент на главной диагонали в исходной
            // строке - нуль, то ищем строку, где элемент
            // того же столбца не нулевой, и меняем строки
            // местами, а так же (исходя из свойства 2
            // определителя), меняем знак результата на
            // противоположный, или, если такую строку
            // найти не удалось - определитель равен нулю
            // и функция завершает работу
            if (copy._matrix[k][k] == 0.0)
            {
                // Изначально устанавливаем индикатор
                // в положение "Не найдено"
                key = false;

                // Идём по строкам, расположенным ниже исходной
                for (unsigned i = k + 1; i < dim; ++i)
                {
                    // Если нашли строку, где в том же столбце
                    // имеется не нулевой элемент
                    if (copy._matrix[i][k] != 0.0)
                    {
                        // Устанавливаем индикатор в положение "Найдено"
                        key = true;

                        // Меняем найденную и исходную строки местами
                        swap(copy._matrix[k], copy._matrix[i]);

                        // Меняем знак результата
                        sign *= -1;

                        break;
                    }
                }
            }

            // Если на каком-то этапе не нашли столбца с ненулевыми элементами
            // ниже k-ой позиции - определитель равен нулю
            if (!key)
                return 0.0;

            // Идём по строкам, которые расположены ниже исходной
            for (unsigned i = k + 1; i < dim; ++i)
            {
                // Запоминаем множитель - отношение элемента очередной
                // строки, расположенного под диагональным элементом
                // исходной строки, к диагональному элементу исходной
                // строки (для того, чтобы постепенно формировать
                // верхнетреугольную матрицу, ведь на каждом шаге
                // внешнего цикла по k внутри данного цикла будет
                // зануляться столбец элементов, расположенных
                // ниже диагонального)
                double multi = copy._matrix[i][k] / copy._matrix[k][k];

                // Отнимаем от очередной строки исходную, умноженную
                // на сохранённый ранее множитель
                for (unsigned j = 0; j < dim; ++j)
                    copy._matrix[i][j] -= multi * copy._matrix[k][j];
            }

            // Добавляем к результату очередное вычисленное значение
            // на главной диагонали, поскольку оно больше не изменится
            result *= copy._matrix[k][k];
        }
    }
    else
        return 0.0;

    // Окончательно формируем результат с учётом получившегося знака
    return sign * result;
}


[DeniSS]

О, я когда-то тоже такое делал. Но там был такой быдлокодинг. . .
Хотя, оно работало, а это главное 

[Qwentor]

Никто не подскажет как скрыть окно консольного приложения? Чтобы ничего не выводило и запускалось скрыто. Да, надо без использования .Net Framework, только на стандартном C++

[gepar]

Кому интересно как деалются приложения под DOS с графикой то я нашёл одну из списка курсовых в инете.
Собственно программа-меню, текст программы:

Код: [Выделить]

#include <stdio.h>
#include <conio.h>
#include <graphics.h>
#include <math.h>

class Point
{
int x, y;
public:
Point(){}
Point(int _x, int _y) { x=_x; y=_y; }
int getx(){ return x; }
int gety(){ return y; }
void draw(int color) { setcolor(color); circle(x, y, 3); }
};

long sd(Point p1, Point p2, Point p3)
{
return ((long)(p3.getx()-p1.getx())*(long)(p2.gety()-p1.gety())-(long)(p2.getx()-p1.getx())*(long)(p3.gety()-p1.gety()));
}

int Peretyn(Point p1, Point p2, Point p3, Point p4)
{
if (sd(p1, p2, p3)*sd(p1, p2, p4)<=0 && sd(p3, p4, p1)*sd(p3, p4, p2)<=0) return 1;
return 0;
}

class Polygon
{
Point p1, p2, p3, p4;
long s;
public:
Polygon(){ s = 0; }
Polygon(Point _p1, Point _p2, Point _p3, Point _p4)
{
p1=_p1; p2=_p2; p3=_p3; p4=_p4; s=0;
Point t;
if (Peretyn(p1, p2, p3, p4))
{
t=p2; p2=p3; p3=t;
}
else
if (Peretyn(p2, p3, p4, p1))
{
t=p1; p1=p2; p2=t;
}
}
void Calc()
{
s+=(long)(p1.getx()-p2.getx())*(long)(p1.gety()+p2.gety());
s+=(long)(p2.getx()-p3.getx())*(long)(p2.gety()+p3.gety());
s+=(long)(p3.getx()-p4.getx())*(long)(p3.gety()+p4.gety());
s+=(long)(p4.getx()-p1.getx())*(long)(p4.gety()+p1.gety());
s=labs(s)/2;
}
long gets() { return s; }
void sets(long _s) { s=_s; }
void draw(int color)
{
setcolor(color);
moveto(p4.getx(), p4.gety());
lineto(p1.getx(), p1.gety());
lineto(p2.getx(), p2.gety());
lineto(p3.getx(), p3.gety());
lineto(p4.getx(), p4.gety());
}
};

float Angle(Point p1, Point p2)
{
long dx = (p2.getx()-p1.getx());
long dy = (p2.gety()-p1.gety());
if (dx==0 && dy==0) return 0;
float res = float(dx*dx)/(float(dx*dx+dy*dy));
if (dx<0) res=-res;
return res;
}

int main()
{
clrscr();
FILE *f=fopen("rect1.txt", "r");
int i, j, n;
char s[200];
fgets(s, 200, f);
for(n=0;!feof(f);++n) fgets(s, 200, f);
rewind(f);
Point* p=new Point[n];
fgets(s, 200, f);
for(i=0; i<n; i++)
{
int x, y;
fscanf(f, "%s%s%s%d%s%s%d%s", s, s, s, &x, s, s, &y, s);
p[i]=Point(x, y);
if (x<p[0].getx() || (x==p[0].getx() && y<p[0].gety()))
{
Point t=p[0]; p[0]=p[i]; p[i]=t;
}
}

Polygon test(Point(10, 0), Point(10, 1), Point(9, 1), Point(9, 2));

for(i=1; i<n; i++)
{
float An = Angle(p[0], p[i]);
int nom = i;
for(j=i+1; j<n; j++)
{
float an = Angle(p[0], p[j]);
if (an<An)
{
An = an; nom = j;
}
}
Point t = p[i]; p[i]=p[nom]; p[nom]=t;
}

int gd=DETECT, gm;
initgraph(&gd, &gm, "e:\\tc\\bgi");
if (graphresult()!=grOk)
{
printf("ERROR!\n");
return 1;
}
setcolor(GREEN);
for(i=0; i<n; i++)
p[i].draw(GREEN);

int i1, i2, i3, i4;
Polygon pmin, pmax; pmin.sets(1000000000);
for(i1=0; i1<n; i1++)
for(i2=i1+1; i2<n; i2++)
for(i3=i2+1; i3<n; i3++)
for(i4=i3+1; i4<n; i4++)
{
if (i1==40 && i2==43 && i3==47 && i4==49)
{
i2=i2;
}
Polygon pp = Polygon(p[i1], p[i2], p[i3], p[i4]);
pp.Calc();
if (pp.gets()>pmax.gets()) pmax=pp;
if (pp.gets()<pmin.gets())
pmin=pp;
}

pmin.draw(RED);
pmax.draw(YELLOW);
getch();
closegraph();
}


Текст програми меню

Код: [Выделить]

#include<stdio.h>
#include<conio.h>
#include<iostream.h>
#include<graphics.h>
#include<string.h>
#include<process.h>
#include <stdlib.h>
#include <math.h>
#include <dir.h>
#include "clases.h"
#define LEFT 75
#define RIGHT 77
#define ENTER 13
char bc_path[255]="e:\\tc\\BIN\\tc.exe";
char bc_path1[255]="e:\\tc\\BIN\\";
int findfile(void);
void f_file(char *fname);
void generateNewInfile(void);
/**********************************************/
class MenuItem
{
int x1;
int y1;
int x2;
int y2;
char str[80];
 public:
void setParam(int xx1,int yy1,int xx2,int yy2,char *sstr)
{
x1=xx1;
y1=yy1;
x2=xx2;
y2=yy2;
strcpy(str,sstr);
};
void showAct(void);
void showPas(void);
void About(void);
void Run(int);
};

void MenuItem::showPas(void)
{
 setviewport(x1,y1,x2,y2,1);
 setfillstyle(1,0);
 bar(1,1,x2,15);
 setfillstyle(1,8);
 bar(1,1,x2-1,14);
 setfillstyle(1,15);
 bar(0,0,x2-2,13);
 setfillstyle(1,7);
 bar(1,1,x2-2,13);
 setcolor(15);
 outtextxy(6,4,str);
 setcolor(0);
 outtextxy(5,3,str);
};

void MenuItem::showAct(void)
{
 setviewport(x1,y1,x2,y2,1);
 setfillstyle(1,0);
 bar(0,0,x2,15);
 setfillstyle(1,9);
 bar(2,3,x2,14);
 setcolor(12);
 outtextxy(7,5,str);
 setcolor(10);
 outtextxy(6,4,str);
};

void MenuItem::About(void)
{
 char str[80];
 window(10,5,70,15);
 FILE*f1=fopen("About.dat","r");
 for(int i=0;i<3;i++)
 {
 fgets(str,80,f1);
 gotoxy(1,i+1);
 printf("%s",str);
 i++;
 };
 getch();
};

void MenuItem::Run(int activ)
{
 switch (activ) {
 case 0: About();
break;
 case 1: f_file("input.txt");
break;
 case 2: f_file("menu.cpp");
break;
 case 3: int res = spawnl(P_WAIT,"circles.exe",NULL);
break;
 case 4: closegraph();
exit(0);
break;
 };
};
/***************************************************/
class Menu
{
MenuItem mits[5];
int nomAct;
int oldNomAct;
void onLeft(void);
void onRight(void);
void onEnter(void);
void show(void);
void show1(void);
 public:
Menu(int xx,int yy);
void getMessage(int msg);
};
Menu::Menu(int xx,int yy)
{
 int x,y;
 x=xx;
 y=yy;
 char str[80];
 FILE *f;
 f=fopen("menudata.txt","r");
 for(int i=0;i<5;i++)
 {
fgets(str,80,f);
mits[i].setParam(x,y,x+strlen(str)*8+1,y+15,str);
x+=strlen(str)*8+3;
 };
 nomAct=0;
 oldNomAct=1;
 show();
};
void Menu::getMessage(int msg)
{
 switch(msg)
 {
case LEFT:
onLeft();
show1();
break;
case RIGHT:
onRight();
show1();
break;
case ENTER:
onEnter();
show1();
 };
};
void Menu::onLeft(void)
{
 oldNomAct=nomAct;
 nomAct=(nomAct==0)?4:nomAct-1;
};

void Menu::onRight(void)
{
 oldNomAct=nomAct;
 nomAct=(nomAct==4)?0:nomAct+1;
};

void Menu::onEnter(void)
{
 mits[nomAct].Run(nomAct);
};

void Menu::show(void)
{
 int gdr=DETECT,gm;
 initgraph(&gdr,&gm,"e:\\tc\\bgi");
 setfillstyle(1,0);
 bar(0,0,639,479);
 for(int i=0;i<5;i++)
if(i==nomAct)
mits[i].showAct();
else
mits[i].showPas();
};

void Menu::show1(void)
{
 for(int i=0;i<5;i++)
if(i==nomAct)
mits[i].showAct();
else
mits[i].showPas();
};
//**********************************************
main()
{
 Menu mnu(40,40);
 while(1)
mnu.getMessage(getch());
}

int findfile()
{
 struct ffblk ffblk;
 if(findfirst(bc_path,&ffblk,0)==0) return 1;
 for(;;)
 {
 cleardevice();
 gotoxy(1,1);
 cout << "\nЌҐ¬®¦г §­ ©вЁ । Єв®а д ©«iў.";
 cout << "\n‚ўҐ¤iвм и«пе в i¬'п д ©«г вЁЇг bc.exe";
 cout << "\nЌ ЇаЁЄ« ¤ C:\\bc\\bin\\bc.exe Ў® exit ¤«п ўЁе®¤г.\n";
 cin >> bc_path;
 if(bc_path[0]=='e'&&bc_path[1]=='x')
 {
 cleardevice();
 return 0;
 }
 if(findfirst(bc_path,&ffblk,0)==0)
 {
 cleardevice();
 return 1;
 }
 else
 {
cout << "\n” ©«\n"<<bc_path<<"\n­Ґ§­ ©¤Ґ­® Ў® ­ҐЄ®а­Єв­Ґ i'¬п д ©«г\n";
getch();
 }
 }
}

void f_file(char *fname)
{
 if(findfile()==0) return;
 char cmd[250];
 strcpy(cmd, "notepad ");
 strcat(cmd,bc_path1);
 strcat(cmd,fname);
 system(cmd);
}


[Mr2]

Скачал PS2SDK а он походу основан на  GNU GCC (MinGW).
Есть две папки:
1 MinGW
2 msys
Вопрос такой:какие команды существуют для MinGW.
Для чего нужна папка msys?

[gepar]

Делаю тут свою курсовую и не получается задействовать оператор перегрузки умножения,  часть кода:

Код: [Выделить]

Matrix& operator*(Matrix &left,const double right)
{
    //результат
    Matrix temp(left);

    for (int i=0;i<left.row;i++)
     for (int j=0;j<left.column;j++)
      temp.matrix[i][j]*=right;

    return temp;
}


Matrix operator*(const double left, const Matrix &right)
{
    return (right * left); //ОШИБКА  no match for 'operator*' in 'right * left'|
}

Ну вот какого фига? Я ведь перезагрузил только что же оператор для умножения матрици на число, почему оно меня хочет позлить. В с++ всё же когда допустил ошибку то фиг её исправишь, помню в паскале ошибка была понятнее, а тут "не найдено" и всё и разгадывай квест почему же ему повылазило что выше же есть перегрузка умножения матрицы на число. Ну и ещё при делении на марицу то же самое: не видит оно перегрузку умножения и всё тут.
Прикрепляю код, надеюсь кто-то сможет ответить.
Кратко о программе: создан класс строка матрицы (указатель на массив double), а потом в классе матрице уже сделан указатель на такие строки, сделано по принципу двухмерного массива в с++ (чтобы обращение шло в виде [m] [n]).
Так как показывать это дело во вт. то буду благодарен за оперативность, ато сам что-то я уже второй час эту ошибку не могу исправить

Добавлено позже:
Mr2,ну я компилирую через Code::Blocks с подключённым MinGW, быстро и удобно. Хотя если тебе просто интересны команды по работе с этим комплиятором то тебе наверное стоит заглянуть на оф.сайт.

[Mr2]

Не знаю что ты намудрил, но жалоб компилятора несколько.
Чего ты хотел не понял. Могу сказать лишь по синтаксису:

Код: [Выделить]

Matrix& operator*(Matrix &left,const double right)
{
    //результат
    Matrix temp(left);

    for (int i=0;i<left.row;i++)
     for (int j=0;j<left.column;j++)
      temp.matrix[i][j]*=right;

    return temp;
}
Ты возвращяешь объект, а в операторе написана ссылка на объект.
Такая же ошибка в Matrix& Matrix:: operator+(Matrix &right).

Код: [Выделить]

Matrix operator*(const double left, const Matrix &right)
{
    return (right * left); //ОШИБКА  no match for 'operator*' in 'right * left'|
}
right -право, left -  лево.

return *this * right.inverted();
*this=*this * right.inverted();

ABRACADABRA!
Похоже торопишься здать курсовую.
Вот так компилируется:

Код: [Выделить]

#include <iostream>
using std::ostream;
using std::istream;

#include "Matrix.h"

// функция для обмена двух строк местами
void Matrix:: swap(Row &a, Row &b)
{
    Row temp=a;
    a=b;
    b=temp;
}

//функция для изменения размера текущей матрицы
void Matrix:: resize(int r,int c,double fill)
{
    if(row!=r || column!=c)
    {
        row=r;
        column=c;
        delete [] matrix;
        matrix=new Row[row];
    }

    for (int i=0;i<row;i++)
     matrix[i].resize(column,fill);
}


//конструктор
Matrix::Matrix(int r,int c,double fill)
{
    row=(r>0 ? r : 1);
    column=(c>0 ? c : 1);
    matrix= new Row[row];
    //заполняем данными матрицу
    for (int i=0;i<row;i++)
     matrix[i].resize(column,fill);
}


//конструктор копии
Matrix::Matrix(const Matrix &right)
{
    if (*this!=right) //проверка на самоприсваивание
    {
        //если размер не совпадает
        if (row!=right.row || column!=right.column)
        {
            delete [] matrix;
            row=right.row;
            column=right.column;
            matrix=new Row[row];

        }
        for (int i=0;i<row;i++)
         matrix[i]=right.matrix[i];
    }
}


Matrix::~Matrix()
{
    delete [] matrix;
}


//обращение к нужному элементу строки
Row& Matrix:: operator[](int numb)
{
    //если такая строка в матрице есть
    if(numb<=row)
     return matrix[numb];
    // иначе вернуть ноль-матрицу
    //else
    // return (Row a());
}

const Row& Matrix:: operator[](int numb) const
{
    //если такая строка в матрице есть
    if(numb<=row)
     return matrix[numb];
    // иначе вернуть ноль-матрицу
    //else
     //return (new Row());
}

//сложение двух матриц
Matrix& Matrix:: operator+(Matrix &right)
{
    Matrix& temp(*this);

    //если колличество строк и столбцов совпадают
    //то мы можем сложить эти матрицы
    if (row==right.row && column==right.column)
    {
        for (int i=0;i<row;i++)
         for (int j=0;j<column;j++)
         temp.matrix[i][j]+=right.matrix[i][j];
    }

    //иначе возвращаем ноль
    else
     temp.resize();
    return temp;
}

Matrix& Matrix:: operator+=(Matrix &right)
{
    *this=*this+right;
    return *this;
}

Matrix Matrix:: operator*(Matrix &right)
{
    //при умножении получим матрицу
    //с колличеством столбцов от первой
    //и колличеством строк второй
    Matrix temp(row,right.column);

    //если можно умножить матрицы
    if (column==right.row)
    {
        for (int i = 0; i < row; i++)
         for (int j = 0; j < right.column; j++)
          for (int k = 0; k < column; k++)
           temp.matrix[i][j] += temp[i][k]*right.matrix[k][j];
    }
    else
     temp.resize();
    return temp;
}

Matrix& Matrix:: operator*=(Matrix &right)
{
    *this=*this*right;
    return *this;
}

Matrix& operator*(Matrix &left,const double right)
{
    //результат
    Matrix& temp(left);

    for (int i=0;i<left.row;i++)
     for (int j=0;j<left.column;j++)
      temp.matrix[i][j]*=right;

    return temp;
}

Matrix& operator*=(Matrix &left, const double right)
{
    left=left*right;
    return left;
}

Matrix operator*(const double left, const Matrix &right)
{
    return (left* right);
}

Matrix& Matrix:: operator-(Matrix &right)
{
    return (*this +right*(-1.0));
}

Matrix& Matrix:: operator-=(Matrix &right)
{
    return (*this=*this + right*(-1.0));
}

Matrix Matrix:: operator/(Matrix &right)
{
    return  right.inverted()* (*this);
}

Matrix Matrix:: operator/=(Matrix &right)
{
    *this= (right.inverted()* (*this))  ;
    return *this;
}

bool Matrix:: operator==(const Matrix &right)
{
    //если колличество строк или столбцов не одинково
    //вернуть false
    if(row!=right.row || column!=right.column)
     return false;

    //если строки не одинаковы
    //вернуть false
    for (int i=0;i<row;i++)
     if(matrix[i]!=right.matrix[i])
      return false;
    //если все элементы одинаковы
    //то вернуть true
    return true;
}

bool Matrix:: operator!=(const Matrix &right)
{
    return !(*this==right);
}

Matrix& Matrix:: operator=(const Matrix &right)
{
    //если не самоприсваивание
    if(*this!=right)
    {
        //если размеры матриц не совпадают
        if (row!=right.row || column!=right.column)
        {
            row=right.row;
            column=right.column;
            delete [] matrix;
            matrix=new Row[row];

            //изменяем размер строк
            //в соответствии с правой матрицей
            for (int i=0;i<row;i++)
             matrix[i].resize(column);
        }

        //присваиваем значения правой матрицы
        //нашей матрице
        for (int i=0;i<row;i++)
         matrix[i]=right.matrix[i];
    }
    return *this;
}

double Matrix:: det()
{
    Matrix temp(*this);
    double result = 1.0;// результат
    int dim = temp.row;
    int sign = 1; //знак определителя
    bool key = true;

    //Только если матрица квадратная
    if (temp.row == temp.column)
    {
        for (int k=0; k<dim;k++)
        {
            if (temp.matrix[k][k]==0.0)
            {
                key=false;
                for (int i=k+1;i<dim;i++)
                {
                    if (temp.matrix[i][k]!=0.0)
                    {
                        key=true;
                        swap(temp.matrix[k], temp.matrix[i]);
                        sign*=-1;
                        break;
                    }
                }
            }
            if (!key)
             return 0.0;

            for (int i=k+1;i<dim;i++)
            {
                double multi = temp.matrix[i][k]/temp.matrix[k][k];
                for (int j = 0; j < dim; ++j)
                 temp.matrix[i][j]-=multi*temp.matrix[k][j];
            }
            result*=temp.matrix[k][k];
        }
    }
    else
     return 0.0;
    return sign*result;
}

Matrix Matrix:: inverted()
{
    //создадим идиничную матрицу
    Matrix temp(row, row);
    //а также копию исходной
    Matrix copy(*this);
    int dim = row;
    if (det() != 0.0)
    {
        for (int i= 0; i<dim; i++)
            temp.matrix[i][i] = 1.0;
        for (int k=0;k<dim;k++)
        {
            if (copy.matrix[k][k]==0.0)
            {
                for (int i=k+1;i<dim;i++)
                {
                    if (copy.matrix[i][k]!=0.0)
                    {
                        swap(copy.matrix[k], copy.matrix[i]);
                        swap(temp.matrix[k], temp.matrix[i]);

                        break;
                    }
                }
            }

            double div = copy.matrix[k][k];
            for (int j=0;j<dim;j++)
            {
                copy.matrix[k][j] /= div;
                temp.matrix[k][j] /= div;
            }

            for (int i=k+1;i<dim;i++)
            {
                double multi=copy.matrix[i][k];
                for (int j=0;j<dim;j++)
                {
                    copy.matrix[i][j] -= multi * copy.matrix[k][j];
                    temp.matrix[i][j] -= multi* temp.matrix[k][j];
                }
            }
        }
        for (int k=dim-1;k>0;k--)
        {
            for (int i=k-1;i+1>0;i--)
            {
                double multi = copy.matrix[i][k];

                for (int j=0;j<dim;j++)
                {
                    copy.matrix[i][j] -= multi * copy.matrix[k][j];
                    temp.matrix[i][j] -= multi * temp.matrix[k][j];
                }
            }
        }
    }
    else
     temp.resize();
    return temp;
}



[gepar]

ABRACADABRA!

Да ладно, всё понятно же, это я ещё класс Row сделал, ато было бы как у преподши в примере указатель указателя указателя на матрицу  вот там бы тебе и было ABBA↓ABBA  Сдать не тороплюсь, тороплюсь сделать чтобы это всё работало, во вт. показать надо что оно есть же ну а там до конца недели потом как я понял дооформить и сдать в печатном виде, теории ещё надёргать на украинском надо, я вот для этой цели нашёл книгу в pdf. Сейчас попробую твои исправления да вот только не понял я твоих замечаний.

Ты возвращяешь объект, а в операторе написана ссылка на объект.

Эммм, и ? а как бы я мог вернуть ссылку кроме как не в виде самого объекта в даном случае, иными словами когда я написал
Matrix& operator*(Matrix &left,const double right)
я что должен возвращать был &temp или что? Признаться честно я ещё когда в Дейтеле проходил перегрузку операторов путался с тем когда надо писать Matrix а когда Matrix&.

[Mr2]

Да ладно, всё понятно же, это я ещё класс Row сделал, ато было бы как у преподши в примере указатель указателя указателя на матрицу  вот там бы тебе и было ABBA↓ABBA  Сдать не тороплюсь, тороплюсь сделать чтобы это всё работало, во вт. показать надо что оно есть же ну а там до конца недели потом как я понял дооформить и сдать в печатном виде, теории ещё надёргать на украинском надо, я вот для этой цели нашёл книгу в pdf. Сейчас попробую твои исправления да вот только не понял я твоих замечаний.

Видимо я просто мало кода видел.

Эммм, и ? а как бы я мог вернуть ссылку кроме как не в виде самого объекта в даном случае, иными словами когда я написал
Matrix& operator*(Matrix &left,const double right)
я что должен возвращать был &temp или что? Признаться честно я ещё когда в Дейтеле проходил перегрузку операторов путался с тем когда надо писать Matrix а когда Matrix&.

Можешь не возвращять Matrix& operator*(Matrix &left,const double right), то есть Matrix operator*(Matrix &left,const double right)

Или вернуть ссылку:

Код: [Выделить]

Matrix& operator*(Matrix &left,const double right)
{
    //результат
    Matrix& temp(left);

    for (int i=0;i<left.row;i++)
     for (int j=0;j<left.column;j++)
      temp.matrix[i][j]*=right;

    return temp;
}

 return (right * left); //ОШИБКА  no match for 'operator*' in 'right * left'|
Видимо у тебя перегружен оператор умножения Matrix *double , а ты умножаешь double left * Matrix right .

[gepar]

Mr2,почему же? Я перегрузил для умножения матрици на число и тут же ниже перегружаю для умножения число на матрицу, при этом в реализации я просто хочу умножить матрицу на число и вернуть это. Собственно после того как ты сделал исправления по поводу возвращаемого типа оператора умножения всё ок, но тем не менее мне непонятно почему всё ок и почему оно тогда у меня ругалось столь непонятно. с++ вообще загадочный, помню когда-то пропустил ; в описании .h файла и он ругался на один из классов который его подключал. Я пока HoRRoR не подсказал даже не думал искать ошибку там, непонятно как-то компиляторы на ошибки указывают как по мне.

[Mr2]

Mr2,почему же? Я перегрузил для умножения матрици на число и тут же ниже перегружаю для умножения число на матрицу,
при этом в реализации я просто хочу умножить матрицу на число и вернуть это.

Код: [Выделить]

Matrix operator*(const double left, const Matrix &right)
{
    return (left* right);
}
Ты про это? Тут походу происходит умножение перегруженным ранее оператором.
friend Matrix &operator*(Matrix&, const double);

Собственно после того как ты сделал исправления по поводу возвращаемого типа оператора умножения всё ок, но тем не менее мне непонятно почему всё ок и почему оно тогда у меня ругалось столь непонятно.

А сама программа работает так как ты задумал? А то я не понял что она должна делать.
Я ещё поменял местами аргументы тут:

Matrix Matrix:: operator/(Matrix &right)
{
    return  right.inverted()* (*this);
}

Matrix Matrix:: operator/=(Matrix &right)
{
    *this= (right.inverted()* (*this))  ;
    return *this;
}

с++ вообще загадочный, помню когда-то пропустил ; в описании .h файла и он ругался на один из классов который его подключал. Я пока HoRRoR не подсказал даже не думал искать ошибку там, непонятно как-то компиляторы на ошибки указывают как по мне.

Обычно когда пропускаешь ; компилятор ругается на следующую строку.

[gepar]

Ты про это? Тут походу происходит умножение перегруженным ранее оператором.

У меня не такой код был, сам посмотри у меня было right*left. При возвращении left*right будет ссылка на эту же перегрузку.

Обычно когда пропускаешь ; компилятор ругается на следующую строку.

Ага, да только когда это в .h файле то ругается он на следующую строку в другом файле где подключён уже этот заголовок.

А сама программа работает так как ты задумал? А то я не понял что она должна делать. Я ещё поменял местами аргументы тут:

Ну пока только проверил что скомпилировалось, перегружу операторы ввода и вывода и проверю.

[Mr2]

У меня не такой код был, сам посмотри у меня было right*left. При возвращении left*right будет ссылка на эту же перегрузку.

Точно, я сейчас проверял, и заметил что friend Matrix &operator*(Matrix&, const double); непричём. Тогда мне вообще непонятно кто перемножает    return ( left * right)?

Ну пока только проверил что скомпилировалось, перегружу операторы ввода и вывода и проверю.

Надо же каждую функцию тестировать, а не когда весь класс сдеаешь.

[gepar]

Mr2,так а где ты нашёл return ( left * right)? Код всей функции приведи.

[Mr2]

Mr2,так а где ты нашёл return ( left * right)? Код всей функции приведи.

Не, я поменял местами right и left, и код компилируется.

Код: [Выделить]

Matrix operator*(const double left, const Matrix &right)
{
    return (left* right);
}
но кто их перемножает если не friend Matrix &operator*(Matrix&, const double);? А она по идеи может перемножать только return ( right *left); И то надо уточнить реально ли это....
По идеи ты должен написать код перемножения(числа на данные класса), а не просто умножить объект на какое то число.
Вообщем я запутался. :'(
Надо самому что нибудь сворганить и разобраться что и как.Потому как надо тестировать все функции а не просто в компиляторе эксперементировать.

[gepar]

Mr2,ну тогда ты меня окончательно запутал при этом мне теперь непонятно почему оно вообще скомпириловалось.
Вот смотри это у меня функция для умножения матрицы на число

Код: [Выделить]

Matrix& operator*(Matrix &left,const double right)
{
    //результат
    Matrix& temp(left);

    for (int i=0;i<left.row;i++)
     for (int j=0;j<left.column;j++)
      temp.matrix[i][j]*=right;

    return temp;
}А это матрици на число, логично что я не хотел бы писать всё заново и просто в реализации оператора поменять местами операнды и пусть используется прошлая перегрузка. Да вот только когда ты поменял местами left и right то мне теперь совсем непонятно где же оно нашло перегрузку числа на матрицу (ведь эта перегрузка и написана для этого случая!).

Код: [Выделить]

Matrix operator*(const double left, const Matrix &right)
{
    return (left* right);
}
Добавлено позже:
В общем вероятно код с такими исправлениями работать не будет либо работать будет не правильно, сейчас проверим.

Добавлено позже:
Нашёл ошибку в классе строка, хорошо бы было если бы оно и ругалось на него если в нём ошибка то была  

Добавлено позже:
Такс, после исправления в Row теперь хоть как-то компилируется ну и печатает саму матрицу (знать матрица создаётся по умолчанию/ с параметрами нормально и печатается тоже), умножение конечно же не работает (ещё бы ему работать, я пока не понял как компилятор вообще умудрился принять практически рекурсивный код при перегрузке умножения на число).

[Mr2]

То есть ты хочешь в одном операторе использовать другой?(в операторе Matrix operator*(const double left, const Matrix &right) вызывается оператор Matrix& operator*(Matrix &left,const double right)?)
Честно сказать не в курсе можно ли проделывать такой фокус с операторами.

Как я понял оператор :

Код: [Выделить]

Matrix operator*(const double left, const Matrix &right)
{
    return (left* right);
}
вызывает сам себя. Но как он умножает я не понял. Может быть просто возвращяет Matrix &right без изменений.Это нужно программу тестировать.

Я перегружал:

Код: [Выделить]

Matrix operator*( const Matrix &right,const float left,)
{
    return ( right*left);
}
И return ( right*left);как у тебя было изначально компилировалась.

[gepar]

Честно сказать не в курсе можно ли проделывать такой фокус с операторами.

А почему бы и нет? Это ведь логично и выглядит коротко, только где-то опять ошибка закралась, а компилятор уже как следствие её здесь видит.

[Mr2]

А почему бы и нет?

А ты видел где либо чтоб оператор вызывал свою версию перегруженного оператора?(int*doubl вызывает double*int)

только где-то опять ошибка закралась, а компилятор уже как следствие её здесь видит.

Это ведь логично и выглядит коротко,

Видимо ты так укоротил что твоя логика неподсильна компилятору.

[gepar]

Mr2,ну так это же не логично писать сначала перегрузку для Класс умножить на double, а потом ещё и отдельно полностью double умножить на Класс. Действие то тоже самое нужно провести только в первом случае класс слева , а во втором класс справа будет от double.

Добавлено позже:
Нашёл ещё ошибку в перегрузке умножения (логическую конечно), откуда их столько на закрадывалось то.

[Mr2]

Mr2,ну так это же не логично писать сначала перегрузку для Класс умножить на double, а потом ещё и отдельно полностью double умножить на Класс.

Логика тут не причём. Как я понял для каждого оператора нужна своя реализация.Есть даже перегрузка для i++ и ++i и у каждой своя реализация.
Ты гдето видел такую перегрузку как у тебя?или это твои личные выдумки?

Нашёл ещё ошибку в перегрузке умножения (логическую конечно), откуда их столько на закрадывалось то.

Я в коде менял местами:

Код: [Выделить]

return  right.inverted()* (*this);
*this= (right.inverted()* (*this));


[HoRRoR]

Mr2, ну и я так делаю, и что? Это тоже мои личные выдумки?

[gepar]

Mr2,нет, я там по строке не той матрицы пошёл под конец. То что ты менял я потом откатил если можно так назвать, тоесть я вернулся к своим старым исходниками.

Добавлено позже:
Тем не меннее я не понимаю почему я получаю ошибку здесь

Код: [Выделить]

Matrix operator*(Matrix &left,const double right)
{
    //результат
    Matrix temp(left);

    for (int i=0;i<left.row;i++)
     for (int j=0;j<left.column;j++)
      temp.matrix[i][j]*=right;

    return temp;
}

Matrix operator*(const double left, const Matrix &right)
{
    return (right*left); //ОШИБКА Matrix.cpp|164|error: no match for 'operator*' in 'right * left'|
}HoRRoR,может ты ещё взгляни да скажи где я туплю, ну не понимаю я почему оно не видит перегрузку выше и всё тут.

Добавлено позже:
Блин, смешно же, как только написал HoRRoR'у только что так и заметил что у меня const во второй же перегрузке, а в первой нет
Matrix operator*(Matrix &left,const double right)
Matrix operator*(const double left, const Matrix &right)