Объединить файлы программы
18.12.2017, 04:21. Показов 810. Ответов 1
Есть 2 программы, на них вылеты при запуске
Программы разбиты на части, подскажите пожалуйста как их объединить в одну (из 3 или двух файлов сделать один для каждой программы)
Программа 1
| C++ (Qt) | 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
| #include <iostream>
#include <cstring>
#include "string.h"
using namespace std;
namespace lab {
String::String() {
size_t len = 0;
_length = len;
_str = new char[len+1];
_str[len] = 0;
}
String::String(char* str) {
size_t len = strlen(str);
_length = len;
_str = new char[len+1];
strncpy(_str, str, len);
_str[len] = 0;
}
/*String::String(const char* str) {
size_t len = strlen(str);
_length = len;
_str = new char[len+1];
strncpy(_str, str, len);
_str[len] = 0;
}*/
String::String(const char* str, size_t len) {
_length = len;
_str = new char[len+1];
strncpy(_str, str, len);
_str[len] = 0;
}
String::String(String const &str) {
size_t len = str._length;
_length = len;
_str = new char[len+1];
strncpy(_str, str._str,len);
_str[len] = 0;
}
String::~String() {
delete[] _str;
}
String& String::operator = (const String& str) {
size_t len = str.length();
delete[] _str;
_length = 0;
_str = new char[len+1];
strncpy(_str, str._str,len);
_str[len] = 0;
_length = len;
return *this;
}
String& String::operator = (const char* str) {
size_t len = strlen(str);
delete[] _str;
_str = new char[len+1];
strncpy(_str, str,len);
_str[len] = 0;
return *this;
}
const bool String::operator == (const String &str) const {
return (_length==str._length) &&
(strcmp(_str,str._str)==0);
}
const bool String::operator == (const char *str) const {
size_t len = strlen(str);
return (_length==len) &&
(strcmp(_str,str)==0);
}
const bool String::operator < (const String& str) const {
return strcmp(_str, str._str) < 0;
}
const bool String::operator > (const String& str) const {
return strcmp(_str, str._str) > 0;
}
char String::operator[](size_t index) const {
if( index>=_length ) return 0;
return *(_str+index);
}
char& String::operator[](size_t index) {
if( index>=_length ) throw "something";
return *(_str+index);
}
String& String::operator += (String str) {
size_t len_a = _length;
size_t len_b = str._length;
size_t len_total = len_a + len_b;
char* strnew = new char[len_total];
strncpy(strnew,_str,len_a);
strncpy(strnew+len_a,str._str,len_b);
strnew[len_total] = 0;
delete[] _str;
_str = strnew;
_length = len_total;
return *this;
}
const String String::operator + (String &str) const {
String temp;
size_t& len_total = temp._length;
char*& strnew = temp._str;
size_t len_a = _length;
size_t len_b = str._length;
len_total = len_a + len_b;
strnew = new char[len_total+1];
strncpy(strnew,_str,len_a);
strncpy(strnew+len_a,str._str,len_b);
strnew[len_total] = 0;
return temp;
}
ostream& operator << (ostream& os, const String& str) {
#ifdef DEBUG
return os << "(" << str._length << ") " << str._str;
#endif
return os << str._str;
}
} // end of namespace |
|
| C++ (Qt) | 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
| #include <iostream>
namespace lab
{
class String {
char* _str;
size_t _length;
public:
String();
String(char*);
//String(const char* = "");
String(const char*, size_t);
String(String const &);
~String();
String& operator = (const String&);
String& operator = (const char*);
const bool operator == (const String&) const;
const bool operator == (const char*) const;
const bool operator < (const String&) const;
const bool operator > (const String&) const;
char operator [] (std::size_t) const;
char& operator [] (std::size_t);
String& operator += (String);
const String operator + (String&) const;
const std::size_t length() const { return _length; };
friend std::ostream& operator << (std::ostream&, const String&);
//friend std::istream& operator << (std::ostream&, const String&);
};
} // end of namespace |
|
| C++ (Qt) | 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
| #include <iostream>
#include "lab/string.h"
//#define DEBUG 1
const int TEST_STRING_SIZE = 1024;
using namespace lab;
String make_test_string() {
char * c_str = new char[TEST_STRING_SIZE + 1];
c_str[TEST_STRING_SIZE - 1] = 0;
String test_string(c_str);
delete[] c_str;
return test_string;
}
int main(int argc, char const *argv[]) {
String s1 = make_test_string();
String s2 = make_test_string();
String s3 = s1 + s2;
s3 += String("abracadabrastring", 5);
s3 = "Hello world!";
std::cout << s3 << std::endl;
return 0;
} |
|
Программа 2
| C++ (Qt) | 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
| #include <iostream>
#include "lab/figure.h"
using namespace lab::figure;
void print_perimeter(const Shape *shape) {
std::cout << shape->name() << ": { ";
std::cout << shape->area() << ", ";
std::cout << shape->perimeter() << " }";
std::cout << std::endl;
}
int main(int argc, char const *argv[]) {
const int NUM_OF_SHAPES = 3;
Shape * shapes[NUM_OF_SHAPES];
shapes[0] = new Rectangle(5.0, 6.0);
shapes[1] = new Circle(5.0);
shapes[2] = new Triangle(2.0, 3.0, 4.0);
for (int i = 0; i < NUM_OF_SHAPES; i++) {
print_perimeter(shapes[i]);
delete shapes[i];
}
// Example of output:
// Rectangle: { 30.0, 22.0 }
return 0;
} |
|
| C++ (Qt) | 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
| #include <string>
#include <stdexcept>
#include <cmath>
namespace lab {
namespace figure {
#define PI 3.1415926535
class Shape {
protected:
std::string _name;
bool _invalid_argument(std::string msg = "") {
throw std::invalid_argument(
std::string(
"in "+_name+" : "+(msg.length()>0?msg:"<0")
).c_str()
);
return false;
};
public:
Shape() {};
virtual const double area() const = 0;
const std::string name() const { return _name; };
virtual const double perimeter() const = 0;
};
class Rectangle : public Shape {
size_t _w, _h;
public:
Rectangle() : _w(0), _h(0) { _name = "rectangle"; };
Rectangle(int w,int h) : _w(static_cast<size_t>(w)), _h(static_cast<size_t>(h)) {
_name = "rectangle";
(((w<0.0)||(h<0.0))&&_invalid_argument());
};
const double area() const { return _w*_h; };
const double perimeter() const { return 2*(_w+_h); };
};
class Circle : public Shape {
size_t _r;
public:
Circle() : _r(0) { _name = "circle"; };
Circle(int r) : _r(static_cast<size_t>(r)) {
_name = "circle";
((r<0.0)&&_invalid_argument());
};
const double area() const { return PI*_r*_r; };
const double perimeter() const { return 2*PI*_r; };
};
class Triangle : public Shape {
size_t _l1, _l2, _l3;
public:
Triangle() : _l1(0), _l2(0), _l3(0) { _name = "triangle"; };
Triangle(int a1, int a2, int a3) : _l1(a1), _l2(a2), _l3(a3) {
_name = "triangle";
(((a1<0.0)||(a2<0.0)||(a3<0.0))&&_invalid_argument());
(((a1+a2<a3)||(a1+a3<a2)||(a2+a3<a1))&&_invalid_argument("a+b<c"));
};
const double area() const { double _p = 0.5*perimeter(); return std::sqrt(_p*(_p-_l1)*(_p-_l2)*(_p-_l3)); };
const double perimeter() const { return _l1+_l2+_l3; };
};
} // of namespace figure
} // of namespace lab |
|
0
|
(
