-
Notifications
You must be signed in to change notification settings - Fork 0
/
2009-07.html
337 lines (257 loc) · 16.8 KB
/
2009-07.html
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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
<!DOCTYPE html>
<html lang="en-us" dir="ltr" itemscope itemtype="http://schema.org/Article">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Blogue do Caloni</title>
<meta name="author" content="Caloni" />
<meta name="generator" content="txt2blog 0.0.1">
<meta property="og:title" content="Blogue do Caloni"/>
<meta property="og:type" content="website"/>
<meta property="og:url" content="http://www.caloni.com.br"/>
<meta property="og:image" content="/img/about-brand.png"/>
<meta property="og:description" content="Write for computers, people and food."/>
<link href="/index.xml" rel="feed" type="application/rss+xml" title="Blogue do Caloni"/>
<link rel="stylesheet" type="text/css" href="/css/custom.css"/>
<link rel="stylesheet" type="text/css" href="/css/jquery-ui.css"/>
<script src="/js/jquery-1.12.4.js"></script>
<script src="/js/jquery-ui.js"></script>
<script src="/js/copy_clipboard.js"></script>
<script>
var quick_search_posts = [
];
</script>
<script src="/js/quick_search.js"></script>
<script src="/js/list.js"></script>
<link rel="icon" href="/img/favicon.ico"/>
</head>
<body style="min-height:100vh;display:flex;flex-direction:column">
<nav class="navbar has-shadow is-white"
role="navigation" aria-label="main navigation">
<div class="container">
<div class="navbar-brand">
<a class="navbar-item" href="months.html">
<div class="is-4"><b>caloni::2009-07</b></div>
</a>
</div>
</div>
</nav>
<div class="container">
<div class="column">
<div style="min-height:56vh">
<div style="padding-bottom: 1em;"></div>
<ul style="list-style: none;">
<li><small><a href="2009-07.html#strings">Strings</a></small></li>
<li><small><a href="2009-07.html#polimorfismo_estatico">Polimorfismo estático</a></small></li>
<li><small><a href="2009-07.html#static_polymorphism">Static Polymorphism</a></small></li>
<li><small><a href="2009-07.html#name_mangling">Name mangling</a></small></li>
<li><small><a href="2009-07.html#a_procura_de_vida_extraterrestre">À procura de vida extraterrestre</a></small></li>
<li><small><a href="2009-07.html#cuidado_com_a_copia_de_arquivos_na_vmware">Cuidado com a cópia de arquivos na VMWare</a></small></li>
</ul>
<span id="strings" title="Strings"/></span>
<section id="section_strings">
<p class="title"><a href="2009-07.html#strings">#</a> Strings</p>
<span class="title-heading">Caloni, 2009-07-07 <a href="coding.html">coding</a><a href="2009-07.html"> <sup>[up]</sup></a> <a href="javascript:;" onclick="copy_clipboard('section#section_strings')"><sup>[copy]</sup></a></span>
<p>Como já vimos centenas e centenas de vezes, memória é apenas memória até que alguém diga que isso vale alguma coisa. Em seu estado latente é o que chamamos formalmente de dados. E dados são bytes armazenados na memória.</p>
<p>No entanto, quando esses dados viram algo de útil em um determinado contexto, não necessariamente alterando-se seu conteúdo na memória, passamos a lidar com informação. Ou seja, é um dado com significado. E informação é a interpretação desses mesmos dados.</p>
<p>A conclusão óbvia para isso, falando de strings, é: uma série de bytes enfileirados na memória pode ser uma string.</p>
<p>Para tanto precisamos apenas de dados (os bytes enfileirados) e significado (uma tabela de símbolos que traduza esses bytes para caracteres e a definição de como a string se organiza).</p>
<p>Por exemplo, uma série de bytes diferentes de zero com valores que representam índices de uma tabela de tradução de caracteres e que termina sua sequência em um byte com o valor zero nele é considerada uma string C, ou string terminada em nulo.</p>
<p>Já uma mesma sequência de bytes no mesmo molde só que sem o byte final com o valor zero, mas com um byte inicial que tem como valor não um índice de caractere, mas o número de bytes subsequentes, isso é uma string Pascal, ou uma string com contador de tamanho.</p>
<p>Agora note por que tanto uma string vazia em Pascal e em C possuem os mesmos dados, mas informação diferente.</p>
<p>Outras strings que não necessariamente possuem terminador nulo: std::string, UNICODESTRING.aspx), strings no kernel.</p>
</section><hr/>
<span id="polimorfismo_estatico" title="Polimorfismo estático"/></span>
<section id="section_polimorfismo_estatico">
<p class="title"><a href="2009-07.html#polimorfismo_estatico">#</a> Polimorfismo estático</p>
<span class="title-heading">Caloni, 2009-07-10 <a href="coding.html">coding</a><a href="2009-07.html"> <sup>[up]</sup></a> <a href="javascript:;" onclick="copy_clipboard('section#section_polimorfismo_estatico')"><sup>[copy]</sup></a></span>
<p>Para explicar polimorfismo, nada como ver as coisas como elas eram. Se você fosse um programador C de vinte anos atrás e criasse as seguintes funções:</p>
<pre>
int soma(int x, int y);
double soma(double x, double y);
int main()
{
int zi = soma(2, 3);
double zd = soma(2.5, 3.4);
return 0;
}
</pre>
<p>Imediatamente o compilador iria acusar os seguintes erros:</p>
<pre>
overload.c
overload.c(2) : warning C4028: formal parameter 1 different from declaration
overload.c(2) : warning C4028: formal parameter 2 different from declaration
overload.c(2) : error C2371: 'soma' : redefinition; different basic types
overload.c(1) : see declaration of 'soma'
</pre>
<p>Isso acontece porque em C **os identificadores são únicos por escopo**. Esse é o motivo por que o seguinte código também está errado:</p>
<pre>
int main()
{
int x = 0;
int x = 1;
return 0;
}
overload.c
overload.c(5) : error C2374: 'x' : redefinition; multiple initialization
overload.c(4) : see declaration of 'x'
</pre>
<p>De volta aos anos 90, isso também está errado em C++. Até por uma questão de lógica: como o compilador pode saber a qual variável estamos nos referindo se usarmos o mesmo nome para duas delas?</p>
<p>Só que existe um truquezinho para impedir essa ambiguidade quando falamos de funções: os parâmetros que ela recebe.</p>
<pre>
int soma(int x, int y);
double soma(double x, double y);
int main()
{
int zi = soma(2, 3); // dois tipos int: chamar soma(int, int)
double zd = soma(2.5, 3.4); // dois tipos double: só pode ser soma(double, double)
return 0;
}
C:\Tests>cl /c overload.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.6030 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.
overload.cpp
C:\Tests>
</pre>
<p>Isso permitiu que em C++ fosse criada a sobrecarga estática, que é exatamente isso: chamar a função não apenas de acordo com seu nome, mas também de acordo com sua assinatura, ou seja, o número e o tipo dos parâmetros recebidos. Chamamos de sobrecarga estática porque isso é feito apenas pelo compilador, não pesando em nada durante a execução do programa.</p>
<p>Entre seus usos mais comuns estão os seguintes:</p>
<p> * Ter funções com o mesmo nome mas que tratam de diferentes parâmetros;</p>
<pre>
* soma(int, int);
* soma(double, double);
* Obs.: Isso ignora, é claro, as facilidades dos templates.
</pre>
<p> * Versões novas da mesma função que recebem parâmetros adicionais;</p>
<pre>
* export_data(void* buffer, int size);
* export_data(void* buffer, int size, unsigned long options);
</pre>
<p> * Mesmo nome de método para setar e obter o valor de uma propriedade;</p>
<pre>
* Class::Property(int x); // setter
* int x Class::Property() const; // getter
</pre>
<p> * Bom, o que mais sua imaginação mandar =)</p>
</section><hr/>
<span id="static_polymorphism" title="Static Polymorphism"/></span>
<section id="section_static_polymorphism">
<p class="title"><a href="2009-07.html#static_polymorphism">#</a> Static Polymorphism</p>
<span class="title-heading">Caloni, 2009-07-10 <a href="coding.html">coding</a> <a href="english.html">english</a><a href="2009-07.html"> <sup>[up]</sup></a> <a href="javascript:;" onclick="copy_clipboard('section#section_static_polymorphism')"><sup>[copy]</sup></a></span>
<p>To explain the polymorphism nothing is better than see how stuff used to be. If you were a twenty old C programmer in the past and created the following functions:</p>
<pre>
int soma(int x, int y);
double soma(double x, double y);
int main()
{
int zi = soma(2, 3);
double zd = soma(2.5, 3.4);
return 0;
}
</pre>
<p>Immediately the compiler would blame you about the following errors:</p>
<pre>
overload.c
overload.c(2) : warning C4028: formal parameter 1 different from declaration
overload.c(2) : warning C4028: formal parameter 2 different from declaration
overload.c(2) : error C2371: 'sum' : redefinition; different basic types
overload.c(1) : see declaration of 'sum'
</pre>
<p>This happens because in C **the identifiers are unique into the scope.** This is the reason why the following code is wrong also:</p>
<pre>
int main()
{
int x = 0;
int x = 1;
return 0;
}
overload.c
overload.c(5) : error C2374: 'x' : redefinition; multiple initialization
overload.c(4) : see declaration of 'x'
</pre>
<p>Back to the 90's, this is also wrong in C++. Even for a logic issue: how the compiler can pick a variable if we're using the same name for both of them?</p>
<p>Even though, there's a little trick to stop the ambiguity when we talk about functions: the parameters that they receives.</p>
<pre>
int soma(int x, int y);
double soma(double x, double y);
int main()
{
int zi = soma(2, 3); // dois tipos int: chamar soma(int, int)
double zd = soma(2.5, 3.4); // dois tipos double: só pode ser soma(double, double)
return 0;
}
C:Tests>cl /c overload.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.6030 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.
overload.cpp
C:Tests>
</pre>
<p>This allowed in C++ the creation of static overload, that is exactly this: to call a function not just by its name, but also to match its signature, the number and the type of the received parameters. We call static because this is done just by the compiler, not creating any overhead during the execution.</p>
<p>Among the most common uses some are as it follows:</p>
<p> * Functions with the same name treating different parameters;</p>
<pre>
* sum(int, int);
* sum(double, double);
* Obs.: This ignores, of course, the templates usefulness.
</pre>
<p> * New version of the same fuction with addictional parameters;</p>
<pre>
* export_data(void* buffer, int size);
* export_data(void* buffer, int size, unsigned long options);
</pre>
<p> * Same method name to set and get the value of a class property;</p>
<pre>
* Class::Property(int x); // setter
* int x Class::Property() const; // getter
</pre>
<p> * Well, whatever your imagination and needs demand =)</p>
</section><hr/>
<span id="name_mangling" title="Name mangling"/></span>
<section id="section_name_mangling">
<p class="title"><a href="2009-07.html#name_mangling">#</a> Name mangling</p>
<span class="title-heading">Caloni, 2009-07-13 <a href="coding.html">coding</a><a href="2009-07.html"> <sup>[up]</sup></a> <a href="javascript:;" onclick="copy_clipboard('section#section_name_mangling')"><sup>[copy]</sup></a></span>
<p>A sobrecarga estática possui algumas desvantagens em relação ao sistema de nomes da boa e velha linguagem C: ela não foi padronizada entre compiladores. O que isso quer dizer na prática é que funções exportadas de bibliotecas dinâmicas (DLLs) vão possuir nomes diferentes dependendo do compilador utilizado (e sua versão). Isso é o que chamamos name mangling.</p>
<p>Em dois projetos usando Visual C++ 2008 e Borland C++ Builder 5 (última versão que funciona direito) eu fiz uma exportação da função soma em linguagem C (o fonte é um .c). Veja o resultado:</p>
<p>Já usando a linguagem C++ (o fonte é um .cpp) temos outro resultado totalmente diferente para nossas duas funções soma descritas no artigo anterior:</p>
<p>Se quiser tentar entender essas letrinhas bizarras, recomendo baixar projetos de exemplo. Se apenas entender que você não conseguirá juntar classes VC++ e Builder usando dllexport.aspx) para tudo quanto é lado, então terminamos por aqui.</p>
</section><hr/>
<span id="a_procura_de_vida_extraterrestre" title="À procura de vida extraterrestre"/></span>
<section id="section_a_procura_de_vida_extraterrestre">
<p class="title"><a href="2009-07.html#a_procura_de_vida_extraterrestre">#</a> À procura de vida extraterrestre</p>
<span class="title-heading">Caloni, 2009-07-20<a href="2009-07.html"> <sup>[up]</sup></a> <a href="javascript:;" onclick="copy_clipboard('section#section_a_procura_de_vida_extraterrestre')"><sup>[copy]</sup></a></span>
<p>Faz uns bons dez anos que eu instalei pela primeira vez em meu Pentium 133 MHz o seti@home, um programinha que se propunha a localizar vida extraterrena através de emissões de rádio capturadas pelas nossas potentes antenas de Arecibo. Ele dizia fazer isso durante o tempo ocioso do meu processador. Como eu sou uma pessoa que costuma costumava confiar bastante nas pessoas, além de ser fã incondicional do filme Contato, instalei sem medo.</p>
<p>Algum tempo se passou e hoje volto a instalar o mesmo programa, agora envolto em um invólucro de programas de mesmo teor chamado Boinc, que junta todas essas redes de trabalho em equipe. O computador é usado hoje em dia para diversos trabalhos que exigem um certo esforço no processamento que torna proibitivo alocar máquinas somente para isso (se não impossível do ponto de vista geográfico).</p>
<p>Eis uma lista dos principais projetos disponíveis através do Boinc que me chamaram a atenção:</p>
<ul><li>Climateprediction.net busca prever as possíveis consequências para o mundo das futuras transformações no clima.</li>
<li>CPUGrid.net é uma simulação molecular de proteínas otimizada para as GPUs da NVidia e o Playstation 3.</li>
<li>Superlink@Technion e ajude os cientistas a encontrar os prováveis genes causadores de fatalidades como câncer, a diabetes, hipertensão e esquizofrenia.</li>
<li>Chess960@home para análise de uma variante do xadrez tradicional que sempre coloca as peças iniciais em posições aleatórias.</li>
<li>PrimeGrid é um gerador de uma base de dados pública de números primos sequenciais, além de procurar por números primos gêmeos gigantes (vai saber).</li>
<li>Quantum Monte Carlo at Home não é o que parece: Estudo da estrutura e da reatividade de moléculas usando a Química Quântica (?).</li>
</ul>
<p>Dentre eles, acabei ficando mesmo com o bom e velho seti@home. Pode me chamar de egoísta, mas mesmo que encontrem a cura do câncer, não será muito produtivo para mim, que possuo questões existenciais que, acredito eu, facilitariam a compreensão das pessoas acerca da nossa extrema pequenez nesse universo, nos colocando cada vez mais no cantinho de nossa existência.</p>
<p>Escolha o seu!</p>
</section><hr/>
<span id="cuidado_com_a_copia_de_arquivos_na_vmware" title="Cuidado com a cópia de arquivos na VMWare"/></span>
<section id="section_cuidado_com_a_copia_de_arquivos_na_vmware">
<p class="title"><a href="2009-07.html#cuidado_com_a_copia_de_arquivos_na_vmware">#</a> Cuidado com a cópia de arquivos na VMWare</p>
<span class="title-heading">Caloni, 2009-07-27<a href="2009-07.html"> <sup>[up]</sup></a> <a href="javascript:;" onclick="copy_clipboard('section#section_cuidado_com_a_copia_de_arquivos_na_vmware')"><sup>[copy]</sup></a></span>
<p>Quebrei a cabeça com uma DLL de hook que não estava funcionando para usuários comuns. No entanto, para qualquer administrador funcionava.</p>
<p>Isso acontece porque quando se arrasta uma DLL recém-compilada para a VMWare ela possui um mecanismo que primeiro cria esse arquivo no temporário do usuário atual e depois move esse arquivo para o lugar onde você de fato arrastou.</p>
<p>Como sabemos, a pasta temporária de um usuário fica em seu perfil, que possui direitos de uso apenas do usuário e dos administradores do sistema. Se eu copio um arquivo de uma pasta restrita para outra pasta os direitos do arquivo permanecem. Isso quer dizer que apenas o usuário atual e os administradores terão acesso ao arquivo, mesmo que se trate de um arquivo para uso de todos.</p>
<p>Resultado: arrastava a nova DLL de hook compilada da pasta de saída direto para a pasta de sistema da máquina virtual e esse caminho através do temporário era seguido, tornando a DLL inacessível para os usuários que eu estava testando.</p>
<p>Solução: após arrastar o arquivo, mude suas permissões. Ou copie-o através do bom e velho copiar/colar. Diferente do arrastar, o Ctrl+C Ctrl+V não gera arquivos temporários.</p>
</section><hr/>
<span style="float: left;">
<a href="2009-06.html">[2009-06]</a>
<a href="2009-08.html">[2009-08]</a>
</span>
</div>
</div>
</section>
<footer class="footer">
<div class="container">
</div>
</footer>
</body>
</html>