/u/32662/kleurpaashaas.png?f=community)
In een class gebruik ik new[] en delete[] om een char* de (de)allocaten.
Deze char* moet rauwe data bevatten, dus ik kan geen string iod gebruiken omdat die de array afkappen bij een \0
Nu dacht ik zelf dat mijn mechaniek aardig werkte, maar op een één of andere manier segfault 'ie altijd in de destructor bij een delete[]....
Header:
Source (alleen boeiende dingen)
Behoorlijk vaag als je het mij vraagt, maar misschien heb ik wat over het hoofd gezien.
Ik vind die hele delete[] zoiezo vaag: hoe weet die 'ie nou hoe groot je *array op dat moment is?
Deze char* moet rauwe data bevatten, dus ik kan geen string iod gebruiken omdat die de array afkappen bij een \0
Nu dacht ik zelf dat mijn mechaniek aardig werkte, maar op een één of andere manier segfault 'ie altijd in de destructor bij een delete[]....
Header:
code:
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
| class E_EXPORT NetPacket
{
public:
NetPacket();
NetPacket(int code, QString argument ="");
NetPacket(int code, char *data, int size = -1);
NetPacket(QString string, bool b =true);
NetPacket(char *data, bool b =true, int size = -1);
~NetPacket();
QString argument();
int code();
char *argumentData();
const char*argumentDataConst() const;
int argumentLength();
void setArgument(QString);
void setArgument(const char *data, int size = -1);
void setCode(int);
void set(char *data, bool removeTrailingNewline = true, int size = -1);
void set(QString, bool removeTrailingNewline = true);
QString toString(bool addTrailingNewline = false);
NetPacket&operator =(const NetPacket&);
operator QString() { return toString(); }
bool checkAnswer(int ok_code =0);
// debug
void print();
private:
int m_datasize;
char *m_data;
int m_code;
}; |
Source (alleen boeiende dingen)
code:
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
| NetPacket::NetPacket()
{
m_data = 0;
m_datasize = 0;
}
NetPacket::NetPacket(int c, QString arg)
{
m_code = c;
m_data = 0;
m_datasize =0;
setArgument(arg);
}
NetPacket::NetPacket(int code, char *data, int size)
{
m_code = code;
m_data = 0;
m_datasize = 0;
setArgument(data, size);
}
NetPacket::NetPacket(QString string, bool b)
{
m_data = 0;
m_datasize = 0;
set(string, b);
}
NetPacket::NetPacket(char *data, bool b, int size)
{
m_data = 0;
m_datasize = 0;
set(data, b, size);
}
NetPacket::~NetPacket()
{
/// Hier gaat het dus altijd fout, niet bij de andere delete[]'s
if(m_data && m_datasize)
delete [] m_data;
}
QString NetPacket::argument()
{
if(m_datasize == 0)
return "";
QString s;
s.setAscii(m_data, m_datasize);
return s;
}
void NetPacket::setArgument(QString s)
{
if(m_data)
{
delete [] m_data;
m_data =0;
}
if(s.isEmpty())
{
m_data = 0;
m_datasize = 0;
return;
}
m_data = new char[s.length()+1];
memcpy(m_data, s.data(), s.length()+1);
m_datasize = s.length();
}
void NetPacket::setArgument(const char *data, int size)
{
if(m_data)
{
delete [] m_data;
m_data =0;
m_datasize =0;
}
if(size < 0)
{
QString s(data);
if(s.isEmpty())
return;
m_data = new char[s.length()+1];
memcpy(m_data, s.data(), s.length()+1);
m_datasize = s.length();
}
else
{
if(size ==0)
return;
m_data = new char[size+1];
memcpy(m_data, data, size);
m_data[size] = '\0';
m_datasize = size;
}
}
void NetPacket::setCode(int i)
{
m_code = i;
}
void NetPacket::print()
{
cout << "'" << QString::number(m_code) << "' '" << m_data << "'" << endl;
}
void NetPacket::set(char *data, bool removeTrailingNewline, int size)
{
if(size < 0)
{
QString s(data);
size = s.length();
}
if(size == 0)
return;
QString code;
int offset, fromend =0;
code.setAscii(data, 3);
m_code = code.toInt();
if(m_code < 100)
offset = 0;
else
offset = 3;
if(removeTrailingNewline)
{
if(data[size-1] == '\n')
fromend = 1;
if(data[size-1-fromend] == '\r')
fromend++;
}
if(size-offset-fromend > 0)
setArgument(data+offset, size-offset-fromend);
}
void NetPacket::set(QString c, bool removeTrailingNewline)
{
m_code = c.left(3).toInt();
if(m_code < 100)
{
setArgument(c);
m_code = 0;
return;
}
QString argument;
argument = c.right(c.length() - 3);
if(removeTrailingNewline)
{
if(argument.at(argument.length()-1) == '\n')
argument = argument.left(argument.length()-1);
if(argument.at(argument.length()-1) == '\r')
argument = argument.left(argument.length()-1);
}
setArgument(argument);
}
NetPacket& NetPacket::operator =(const NetPacket& p)
{
m_code = p.m_code;
if(p.argumentDataConst() && p.m_datasize)
setArgument(p.argumentDataConst(), p.m_datasize);
return *this;
} |
Behoorlijk vaag als je het mij vraagt, maar misschien heb ik wat over het hoofd gezien.
Ik vind die hele delete[] zoiezo vaag: hoe weet die 'ie nou hoe groot je *array op dat moment is?
:strip_exif()/u/7759/red_cat.gif?f=community)
/u/27299/hoofd.png?f=community)
Echte code documenteert zichzelf, en dat doe je door in de naam aan te geven waar de parameter voor dient.
toch maar weer beter lezen volgende keer ;-)