Форум программистов, компьютерный форум CyberForum.ru

Неявное преобразование типов? - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Простой массив в с++ нужна прога http://www.cyberforum.ru/cpp-beginners/thread839050.html
Срочняк нужна прога ребят,пятая задачка Блин если тут реально мне помогут, я рад буду айайай) Потому что профессией на которую учусь стал заинтересоваться норм так)
C++ Ошибка с strtok - как исправить? Вот например: #include <iostream> #include <fstream> using namespace std; void main () { char text="gh.gh.g hghgh o3 jf7 fk., fj", *text1, *text2; text1=strtok(text, " "); \\здесь text1 должно принимать значение gh.gh.g - собственно все правильно получается http://www.cyberforum.ru/cpp-beginners/thread839049.html
Найти прямоугольник, наибольшей площади, заполненный единицами C++
Дан двумерный массив, заполненный нулями и единицами. Найти прямоугольник, наибольшей площади, заполненный единицами.
Задается словарь. Найти в нем все анаграммы C++
задали задачу Задается словарь. Найти в нем все анаграммы (слова, составленные из одних и тех же букв). смысл понятен,но непонятно как проверять посимвольно, чтоб выдавал правильный результат! Помогите!!
C++ Класс и vector http://www.cyberforum.ru/cpp-beginners/thread839028.html
всем доброго времени суток,задача состоит в том что бы данные классов хранились в векторе,что я и пытался сделать. #include <iostream> #include <algorithm> #include <vector> using namespace std; #define n 40
C++ Создать список из слов файла Подскажите пожалуйста как написать программу, которая считывает текст по словам из файла и создаёт из него список. подробнее

Показать сообщение отдельно
Черный ворон
129 / 123 / 6
Регистрация: 31.01.2012
Сообщений: 435
16.04.2013, 10:38  [ТС]
vector.h
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#pragma once
#ifndef VECTOR_H
#define VECTOR_H
#include <iostream.h>
//using namespace std;
class Vector
{
private:
    int *vector;
    int size;
public:
    Vector(void);
    Vector(int n);
   // Vector(int n, ...);
    Vector(int n, int *array);
    Vector(Vector& vector);
 
    ~Vector(void);
 
    int Length();
 
    int Max();
    int Min();
 
    int* begin();
    int *end();
 
    Vector& operator = (const Vector& vect);
    int& operator [] (int index);
 
    Vector& operator + ();
    Vector& operator - ();
 
    Vector& operator +=(Vector& v);
    Vector& operator -=(Vector& v);
    Vector& operator *=(int n);
 
    friend bool operator == (const Vector& v1, const Vector& v2);
    friend bool operator != (const Vector& v1, const Vector& v2);
 
    friend Vector& operator + (Vector& left, Vector& right);
    friend Vector& operator - (Vector& left, Vector& right);
    friend Vector& operator * (int num, Vector& right);
    friend Vector& operator * (Vector& left, int num);
 
    friend /*std::*/ostream& operator<<(/*std::*/ostream& s, Vector& vect);
    friend /*std::*/istream& operator>>(/*std::*/istream& s, Vector& c);
 
};
 
#endif // VECTOR_H

vector.cpp
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#pragma once
#include "vector.h"
#include <iostream>
 
Vector::Vector(void)
{
    size=0;
}
 
Vector::Vector(int n)
{
    size=n;
    vector=new int [size];
    memset(vector,0,size*sizeof(int));
}
 
Vector::Vector(int n, int *array)
{
    size=n;
    vector=new int [size];
    for (int i=0; i<size; i++) vector[i]=array[i]; 
}
 
/*Vector::Vector(int n, ...)
{
    size=n;
    vector=new int [n];
    ///////////////////////////
}*/
 
Vector::Vector(Vector &vect)
{
    size=vect.size;
    vector=new int [size];
    *this=vect;
}
 
Vector::~Vector()
{
    delete []vector;
}
 
int Vector::Length()
{
    return this->size;
}
 
int Vector::Max()
{
    int max=this->vector[0];
    for (int i=0; i<this->Length(); i++) if (this->vector[i]>max) max=this->vector[i];
    return max;
}
 
int Vector::Min()
{
    int min=vector[0];
    for (int i=0; i<Length(); i++) if (this->vector[i]<min) min=this->vector[i];
    return min;
}
 
int* Vector::begin()
{
    return this->vector;
}
 
int* Vector::end()
{
    return (&vector[size-1]+sizeof(int));
}
 
 
Vector& Vector::operator + () {return *this;}
Vector& Vector::operator - ()
{
        static Vector temp(this->size);
        temp=*this;
        temp=temp*-1;
        return temp;
}
 
 
Vector& Vector::operator +=(Vector& v){
        return *this=*this+v;
}
 
Vector& Vector::operator -=(Vector& v){
        return *this=*this-v;
}
 
Vector& Vector::operator *=(int n){
        return *this=*this*n;
}
 
/*friend*/ Vector& operator + (Vector& left, Vector& right)
{
    static Vector tempAdd(left.size);
    for (int i=0; i<left.size; i++) tempAdd[i]=left[i]+right[i];
    return tempAdd;
}
 
/*friend*/ Vector& operator - (Vector& left, Vector& right)
{
    static Vector tempSub(left.size);
    for (int i=0; i<left.size; i++) tempSub[i]=left[i]-right[i];
    return tempSub;
}
 
/*friend*/ Vector& operator * (int num, Vector& right)
{
    static Vector tempMult(right.size);
    for (int i=0; i<right.size; i++) tempMult[i]=num*right[i];
    return tempMult;
}
 
/*friend*/ Vector& operator * (Vector& left, int num)
{
    static Vector tempMult(left.size);
    for (int i=0; i<left.size; i++) tempMult[i]=left[i]*num;
    return tempMult;
}
 
Vector& Vector::operator =(const Vector& vect)
{
    if (size!=0) delete []vector;
    size=vect.size;
    vector = new int [size];
    for (int i=0; i<size; i++) vector[i]=vect[i];
    return *this;
}
 
bool operator == (const Vector& v1, const Vector& v2)
{
        if (v1.size!=v2.size) return false;
        for (int i=0; i<v1.size; i++) if (v1.vector[i]!=v2.vector[i]) return false;
        return true;
}
 
bool operator != (const Vector& v1, const Vector& v2)
{
        if (v1.size==v2.size) return false;
        for (int i=0; i<v1.size; i++) if (v1.vector[i]==v2.vector[i]) return false;
        return true;
}
 
std::ostream& operator<<(std::ostream& s, Vector& vect)
{
    for (int i=0; i<vect.Length(); i++) s<<vect[i]<<" ";
        return s;
}
 
std::istream& operator>>(std::istream& s, Vector& vect){
    for (int i=0; i<vect.Length(); i++) s>>vect[i];
        return s;
}
 
int& Vector::operator [] (int index)
{
    return vector[index];
}


matrix.h
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#pragma once
#ifndef MATRIX_H
#define MATRIX_H
#include "vector.h"
 
class Matrix
{
private:
    int m;
    int n;
    Vector *matrix;
public:
    Matrix();
    Matrix(int m, int n);
    Matrix(int n);
    Matrix(int n, int **array);
    Matrix(int m, int n, int **array);
    Matrix(Matrix& matr);
    Matrix(const Vector& v);
 
    ~Matrix();
 
    int ndim();
    int mdim();
 
    int* begin();
    int* end();
 
    int Max();
    int Min();
 
    Vector& operator [] (int index);
    Matrix& operator + ();
    Matrix& operator - ();
    Matrix& operator = (Matrix& matr);
 
    Matrix& operator +=(Matrix& m);
    Matrix& operator -=(Matrix& m);
    Matrix& operator *=(int n);
 
    friend bool operator == (const Matrix& m1, const Matrix& m2);
    friend bool operator != (const Matrix& m1, const Matrix& m2);
 
    friend Matrix& operator + (Matrix& left, Matrix& right);
    friend Matrix& operator - (Matrix& left, Matrix& right);
    friend Matrix& operator * (int num, Matrix& right);
    friend Matrix& operator * (Matrix& left, int num);
 
    friend Matrix& operator * (Matrix& left, Matrix & right);
 
    friend std::ostream& operator<<(std::ostream& s, Matrix& matr);
    friend std::istream& operator>>(std::istream& s, Matrix& matr);
 
};
 
#endif // MATRIX_H


matrix.cpp
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
#pragma once
#include "matrix.h"
 
//#include "vector2.cpp"
 
Matrix::Matrix()
{
    m=n=0;
}
 
Matrix::Matrix(int n)
{
    this->m=this->n=n;
    matrix=new Vector[m];
    Vector temp(n);
    for (int i=0; i<m; i++) matrix[i]=temp;
}
 
Matrix::Matrix(int m, int n)
{
    this->m=m;
    this->n=n;
    Vector temp(n);
    matrix=new Vector[m];
    for (int i=0; i<m; i++) this->matrix[i]=temp;
}
 
Matrix::Matrix(int n, int **array)
{
    this->m=this->n=n;
    Vector temp(n);
    matrix=new Vector[m];
    for (int i=0; i<m; i++){
        matrix[i]=temp;
        for (int j=0; j<n; j++)
                this->matrix[i][j]=array[i][j];
        }
}
 
Matrix::Matrix(int m, int n, int **array)
{
    this->m=m;
    this->n=n;
    Vector temp(n);
    matrix=new Vector[m];
    for (int i=0; i<m; i++){
        matrix[i]=temp;
        for (int j=0; j<n; j++)
                this->matrix[i][j]=array[i][j];
        }
}
 
Matrix::Matrix(Matrix &matr)
{
    this->n=matr.n;
    this->m=matr.m;
    Vector temp(n);
    matrix=new Vector[m];
    for (int i=0; i<m; i++) this->matrix[i]=temp;
    *this=matr;
}
 
Matrix::Matrix(const Vector& v)
{
        this->m=1;
        this->n=v.Length();
        matrix=new Vector[m];
        matrix[0]=v;
}
 
Matrix& Matrix::operator + () {return *this;}
Matrix& Matrix::operator - ()
{
        static Matrix temp(this->m, this->n);
        temp=*this;
        temp=temp*-1;
        return temp;
}
 
 
Matrix& Matrix::operator =(Matrix& matr)
{
    if ((n!=0)&&(m!=0)) delete []matrix;
    n=matr.n;
    m=matr.m;
    matrix=new Vector[m];
//    Vector temp(n);
    for (int i=0; i<m; i++) matrix[i]=matr[i];
    return *this;
}
 
 
 
int Matrix::ndim(){return n;}
int Matrix::mdim(){return m;}
 
int Matrix::Max()
{
        int max=matrix[0].Max();
        for (int i=0; i<m; i++) if(matrix[i].Max()>max) max=matrix[i].Max();
        return max;
}
int Matrix::Min()
{
        int min=matrix[0].Min();
        for (int i=0; i<m; i++) if(matrix[i].Min()<min) min=matrix[i].Min();
        return min;
}
 
int* Matrix::begin()
{
        return (this->matrix[0].begin());
}
int* Matrix::end()
{
        return (&matrix[m-1][n-1]+sizeof(int));
}
 
Vector& Matrix::operator [] (int index)
{
    return matrix[index];
}
 
bool operator == (const Matrix& m1, const Matrix& m2)
{
        if (m1.m!=m2.m) return false;
        if (m1.n!=m2.n) return false;
        for (int i=0; i<m1.m; i++) if (m1.matrix[i]!=m2.matrix[i]) return false;
        return true;
}
 
bool operator != (const Matrix& m1, const Matrix& m2)
{
        if (m1.m==m2.m) return false;
        if (m1.n==m2.n) return false;
        for (int i=0; i<m1.m; i++) if (m1.matrix[i]==m2.matrix[i]) return false;
        return true;
}
 
Matrix& operator + (Matrix& left, Matrix& right)
{
        if (left.m==right.m) exit(0);
        if (left.n==right.n) exit(0);
        static Matrix temp(left.m,left.n);
        for (int i=0; i<left.m; i++) temp[i]=left[i]+right[i];
        return temp;
}
 
Matrix& operator - (Matrix& left, Matrix& right)
{
        if (left.m==right.m) exit(0);
        if (left.n==right.n) exit(0);
        static Matrix temp(left.m,left.n);
        for (int i=0; i<left.m; i++) temp[i]=left[i]-right[i];
        return temp;
}
 
Matrix& operator * (int num, Matrix& right)
{
        static Matrix temp(right.m,right.n);
        for (int i=0; i<right.m; i++) temp[i]=num*right[i];
        return temp;
}
 
Matrix& operator * (Matrix& left, int num)
{
        static Matrix temp(left.m,left.n);
        for (int i=0; i<left.m; i++) temp[i]=left[i]*num;
        return temp;
}
 
Matrix& Matrix::operator +=(Matrix& m){
        return *this=*this+m;
}
 
Matrix& Matrix::operator -=(Matrix& m){
        return *this=*this-m;
}
 
Matrix& Matrix::operator *=(int n){
        return *this=*this*n;
}
 
 
Matrix& operator * (Matrix& left, Matrix & right)
{
       if (left.n!=right.m) exit(0);
       static Matrix temp(left.m, right.n);
       for (int i=0; i<left.m; i++){
        for (int j=0; j<right.n; j++){
                temp[i][j]=0;
                for (int r=0; r<left.n; r++)
                temp[i][j]+=left[i][r]*right[r][j];
        }
       }
       return temp;
}
 
 
 
std::ostream& operator<<(std::ostream& s, Matrix& matr)
{
    for (int i=0; i<matr.m-1; i++){
        for (int j=0; j<matr.n; j++) s<<matr[i][j]<<" ";
        s<<endl;}
        for (int j=0; j<matr.n; j++) s<<matr[matr.m-1][j]<<" ";
        return s;
}
 
Matrix::~Matrix()
{
    delete []matrix;
}
 
std::istream& operator>>(std::istream& s, Matrix& matr){
    for (int i=0; i<matr.m; i++)
        for (int j=0; j<matr.n; j++) s>>matr[i][j];
        return s;
}


main.cpp
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//#include <QtCore/QCoreApplication>
#pragma once
#include "vector2.cpp"
#include "matrix.cpp"
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    //QCoreApplication a(argc, argv);
    /*int tA[5], tB[5]; for (int i=0; i<5; i++) {tA[i]=i+1; tB[i]=i+1+5;}
    Vector A(sizeof(tA)/sizeof(tA[0]),tA), B(sizeof(tB)/sizeof(tB[0]), tB);
    Vector C;
    C=A+B;
        cout<<A<<endl<<B<<endl;
        //cout<<D<<endl;
    cout<<C<<endl;
    Vector *z;
    int k=10;
    z=new Vector[k];
    for (int i=0; i<k; i++) {z[i]=A; cout<<z[i]<<endl;}   */
 
 
    int tt[3][3]={{1,2,3},{4,5,6},{7,8,9}}, zz[3]={10,11,12};
    int **tt2;
    Vector zz2(3,zz);
    cout<<zz2<<endl;
    tt2=new int* [3];
    for (int i=0; i<3; i++) tt2[i]=new int[3];
    for (int i=0; i<3; i++)
        for (int j=0; j<3; j++) tt2[i][j]=tt[i][j];
        Matrix t(3,tt2);
    cout<<t<<endl;
    Matrix f=t;
    cout<<"======"<<endl;
    //Matrix b;//=zz2;
 
    //cout<<"b: "<<endl<<b<<endl;
    cout<<t*zz2<<endl;
 
 
 
    system("pause");
    
    return 0;//a.exec();
}


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

из особенностей. этот код я сначала компилирую в Borland c++ builder 6. после с минимальными изменениями (#pragma once на #ifndef итд) затем в qt-sdk. но ошибки (что логично в тех же строках, просто в qt из-за кодировки сообщения об ошибках кракозябрами выходят)
как-то так
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru