{"id":1917,"date":"2022-02-01T15:44:55","date_gmt":"2022-02-01T18:44:55","guid":{"rendered":"https:\/\/elemarjr.com\/cppmoderno\/?p=1917"},"modified":"2025-06-18T16:07:19","modified_gmt":"2025-06-18T19:07:19","slug":"como-funciona-o-build-em-c-apendice-a-v-1-0","status":"publish","type":"post","link":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/como-funciona-o-build-em-c-apendice-a-v-1-0\/","title":{"rendered":"Como funciona o “build” em C++ \/\/ Ap\u00eandice A v 1.0"},"content":{"rendered":"Fica mais f\u00e1cil entender algumas caracter\u00edsticas de C++ sabendo como arquivos com c\u00f3digo-fonte na linguagem s\u00e3o processados e combinados para gerar, finalmente, execut\u00e1veis e bibliotecas din\u00e2micas ou est\u00e1ticas.\n
\r\n

Bibliotecas est\u00e1ticas e din\u00e2micas<\/p>\r\n<\/p>\n

Bibliotecas s\u00e3o blocos de c\u00f3digo que s\u00e3o reutiliz\u00e1veis em v\u00e1rios programas. Us\u00e1-las economiza tempo, eliminando a necessidade de reescrever o c\u00f3digo v\u00e1rias vezes.<\/p>\n

Bibliotecas est\u00e1ticas (geralmente, em Windows, arquivos com extens\u00e3o .lib<\/code>), embora reutiliz\u00e1veis em v\u00e1rios programas, s\u00e3o bloqueadas em um programa no build<\/em>. Por outro lado, bibliotecas din\u00e2micas ou compartilhadas (em Windows, extens\u00e3o .dll<\/code>) existem como arquivos separados fora do arquivo execut\u00e1vel.<\/p>\n

<\/div>\n

Neste ap\u00eandice, apresento alguns fundamentos do processo de\u00a0build\u00a0<\/em>do C++, fundamentais, para que voc\u00ea consiga ser “efetivo” em menos tempo, com menos chances de “atirar no pr\u00f3prio p\u00e9”.<\/p>\n

\r\n\r\n\r\n\r\n
\"\"<\/td>\r\n\"\" <\/p>\n

Um p\u00e9ssimo trabalhador culpa suas ferramentas.<\/em><\/p>\n

\r\n

Prov\u00e9rbios Islandenses<\/strong><\/p>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\n

Compila\u00e7\u00e3o e linking<\/em><\/h2>\n

Comecemos simples. O\u00a0build\u00a0<\/em>em C++ inclui duas etapas principais: compila\u00e7\u00e3o<\/span> e\u00a0linking<\/em><\/span>.<\/p>\n

O processo de compila\u00e7\u00e3o<\/span> processa todos os arquivos contendo c\u00f3digo-fonte individualmente e de maneira isolada.<\/strong> Ou seja, para o compilador, quando um arquivo est\u00e1 sendo processado \u00e9 como se fosse o \u00fanico, devendo dispor, de alguma meneira, todas as informa\u00e7\u00f5es necess\u00e1rias para sua valida\u00e7\u00e3o.<\/p>\n

Obviamente, nenhum “arquivo com c\u00f3digo-fonte” \u00e9 uma ilha. A raz\u00e3o de um sistema ter v\u00e1rios arquivos \u00e9, exatamente, dividir o c\u00f3digo, segundo algum crit\u00e9rio, para facilitar manuten\u00e7\u00e3o e evolu\u00e7\u00e3o, de forma que \u00e9 natural que c\u00f3digo de um arquivo “chame” c\u00f3digo (fun\u00e7\u00f5es e tipos de usu\u00e1rio) em outros arquivos. A “liga\u00e7\u00e3o” entre os programas de diversos arquivos com c\u00f3digo-fonte \u00e9 realizada atrav\u00e9s do processo linking<\/span>.<\/em><\/strong><\/p>\n

O compilador “entende” o c\u00f3digo “de cima para baixo”<\/h2>\n

Como j\u00e1 foi dito, durante a compila\u00e7\u00e3o, cada arquivo \u00e9 processado individualmente e de maneira isolada<\/strong>. Mais do que isso, na medida em que o compilador “l\u00ea” um c\u00f3digo em um arquivo, precisa conhecer qualquer refer\u00eancia utilizada de maneira a determinar\u00a0 sua validade e corre\u00e7\u00e3o.<\/p>\n

No c\u00f3digo que segue, por exemplo, o compilador consegue “entender” o c\u00f3digo porque, n\u00e3o h\u00e1, em momento algum, informa\u00e7\u00e3o faltando para valida\u00e7\u00f5es.<\/p>\n

\/\/ main.cpp\r\nint doSomething() {\r\n    return 0;\r\n}\r\n\r\nint main(){\r\n    auto a = doSomething();\r\n    \/\/ ...\r\n}\r\n<\/pre>\n
J\u00e1 o c\u00f3digo abaixo n\u00e3o compila! No momento em que acontece chamada para a fun\u00e7\u00e3o doSomething<\/code> ela ainda n\u00e3o \u00e9 “conhecida”.<\/p>\n
\/\/ main.cpp\r\nint main(){\r\n    auto a = doSomething(); \/\/ THIS CODE DOES NOT COMPILE!\r\n    \/\/ ...\r\n}\r\n\r\nint doSomething() {\r\n    return 0;\r\n}\r\n<\/pre>\n
Para que n\u00e3o nos preocupemos com a ordem em que as fun\u00e7\u00f5es aparecem no c\u00f3digo, a sa\u00edda \u00e9 incluir no in\u00edcio “defini\u00e7\u00f5es” das implementa\u00e7\u00f5es que aparecer\u00e3o a seguir. No exemplo que segue, definimos a fun\u00e7\u00e3o doSomething<\/code> antes de qualquer evoca\u00e7\u00e3o. Dessa forma, o compilador “sabe” que h\u00e1 uma fun\u00e7\u00e3o com esse nome e, tamb\u00e9m, consegue determinar corretamente o tipo da vari\u00e1vel a<\/code>.<\/p>\n
\/\/ main.cpp\r\nint doSomething();\r\n\r\nint main(){\r\n    auto a = doSomething();\r\n    \/\/ ...\r\n}\r\n\r\nint doSomething() {\r\n    return 0;\r\n}\r\n<\/pre>\n
Essa medida, ali\u00e1s, autoriza “levar” a implementa\u00e7\u00e3o concreta de doSomething<\/code> para outro arquivo com c\u00f3digo fonte (func.cpp<\/code>).<\/p>\n
\/\/ func.cpp\r\nint doSomething() {\r\n    return 0;\r\n}\r\n<\/pre>\n
#include<\/code> explicado<\/h2>\n
Incluir no in\u00edcio de um arquivo de c\u00f3digo-fonte uma rela\u00e7\u00e3o exaustiva de declara\u00e7\u00f5es de fun\u00e7\u00f5es e tipos (classes e estruturas) torna o c\u00f3digo mais dif\u00edcil de entender, manter e evoluir.<\/strong> Afinal, caso ocorram breaking changes<\/em> nas implementa\u00e7\u00f5es concretas, elas s\u00f3 ser\u00e3o percebidas durante o linking<\/em>.<\/p>\n
O “estilo C++” para lidar com declara\u00e7\u00f5es \u00e9, para cada arquivo de c\u00f3digo-fonte, criar um arquivo de “cabe\u00e7alho” relacionando as defini\u00e7\u00f5es de fun\u00e7\u00f5es e tipos que ele devem ficar expostas.<\/p>\n
\/\/ func.h\r\n#ifndef FUNC_H\r\n#define FUNC_H\r\n\r\nint doSomething();\r\n\r\n#endif \/* FUNC_H *\/\r\n<\/pre>\n
Os arquivos de cabe\u00e7alho s\u00e3o, ent\u00e3o, “inclu\u00eddos” em arquivos de c\u00f3digo-fonte que ser\u00e3o consumidores.<\/p>\n
\/\/ main.cpp\r\n#include \"func.h\"\r\n\r\nint main(){\r\n    auto a = doSomething();\r\n    \/\/ ...\r\n}\r\n<\/pre>\n
A inclus\u00e3o, \u00e9 executada pela diretiva de pr\u00e9-processamento #include<\/code>, antes do trabalho do compilador, por um “pr\u00e9-processador” que, literalmente, deixa o c\u00f3digo pronto para a compila\u00e7\u00e3o.<\/p>\n
\r\n
Pr\u00e9-processador<\/p>\r\n<\/p>\n
Pr\u00e9-processamento \u00e9 uma esp\u00e9cie de “etapa pr\u00e9via” executada antes da compila\u00e7\u00e3o e \u00e9 executado por um “motor” designado como “pr\u00e9-processador”.<\/p>\n
O pr\u00e9-processador procura quaisquer diretivas de pr\u00e9-processamento (linhas de c\u00f3digo come\u00e7ando com um #<\/code>) e altera o c\u00f3digo de alguma forma, geralmente adicionando ou removendo linhas.<\/p>\n
A diretiva #include<\/code>, por exemplo, literalmente insere o conte\u00fado do arquivo especificado na posi\u00e7\u00e3o em que aparece.<\/p>\n
<\/div>\n
As diretivas #ifndef<\/code>, #define<\/code>e #endif<\/code> ajudam o pr\u00e9-processador a n\u00e3o “incluir acidentalmente” um mesmo conjunto de defini\u00e7\u00f5es mais de uma vez.<\/p>\n
\r\n
#pragma once<\/code><\/p>\r\n<\/p>\n
As diretivas #ifndef<\/code>, #define<\/code>e #endif<\/code>para impedir duplicidade de inclus\u00e3o de declara\u00e7\u00f5es \u00e9 um pattern <\/em>consolidado, aderente a especifica\u00e7\u00e3o do C++. Entretanto, \u00e9 uma solu\u00e7\u00e3o “verbosa” para um problema recorrente.<\/p>\n
Atualmente, todos os compiladores do mercado suportam a diretiva #pragma once<\/code> que atende ao mesmo objetivo do pattern.<\/em><\/p>\n
\/\/ func.h\r\n#pragma once\r\n\r\nint doSomething();\r\n<\/pre>\n
<\/div>\n
Macros<\/h2>\n
O pr\u00e9-processador do C++ \u00e9 tremendamente poderoso e perigoso. Ele “altera” o c\u00f3digo fonte, expandindo trechos conforme defini\u00e7\u00f5es, aparentando “enganosamente” uma fun\u00e7\u00e3o.<\/strong><\/p>\n
#define MAX(a,b) (a > b ? a : b)\r\n\r\n#include <iostream>\r\nusing namespace std ;\r\n\r\nint main() {\t\r\n    int x = 10, y = 20;\r\n    cout << \"Macro Max(x,y) = \" << MAX(x,y) << endl;\r\n    return 0;\r\n}\r\n<\/pre>\n
No exemplo acima, a macro MAX<\/code>, quando interpretada pelo pr\u00e9-processador altera o c\u00f3digo-fonte fazendo substitui\u00e7\u00e3o conforme indicado no modelo. Ap\u00f3s o pr\u00e9-processador, o c\u00f3digo resultante ser\u00e1 como segue:<\/p>\n
\/\/ ... conteudo de iostream ...\r\nusing namespace std ;\r\n\r\nint main() {\t\r\n    int x = 10, y = 20;\r\n    cout << \"Macro Max(x,y) = \" << (x > y ? x : y) << endl;\r\n    return 0;\r\n}\r\n<\/pre>\n
Macros s\u00e3o “entregues” pelo pr\u00e9-processador que n\u00e3o valida, de forma alguma, a corre\u00e7\u00e3o do c\u00f3digo. O exemplo abaixo, por exemplo, n\u00e3o acusa falta de um par\u00eantese na macro. O erro ser\u00e1 indicado, s\u00f3 mais tarde, pelo compillador, na linha onde aconteceu a substitui\u00e7\u00e3o.<\/p>\n
#define MAX(a,b) (a > b ? a : b\r\n\r\n#include <iostream>\r\nusing namespace std ;\r\n\r\nint main() {\t\r\n    int x = 10, y = 20;\r\n    cout << \"Macro Max(x,y) = \" << MAX(x,y) << endl;\r\n    return 0;\r\n}\r\n<\/pre>\n
No passado, macros eram utilizadas em demasia e dificultavam consideravelmente a identifica\u00e7\u00e3o de erros de compila\u00e7\u00e3o. Modernamente, os benef\u00edcios do\u00a0inlining\u00a0<\/em>proporcionado pelas macros \u00e9 resolvido de maneira mais eficiente com o modificador inline<\/code> em fun\u00e7\u00f5es.<\/p>\n
H\u00e1 bem mais…<\/h2>\n
Essa \u00e9 apenas uma breve introdu\u00e7\u00e3o a como funciona o\u00a0build\u00a0<\/em>do C++. H\u00e1 muitos detalhes e recursos adicionais que podem e precisam ser explorados.<\/p>\n","protected":false},"excerpt":{"rendered":"
Neste ap\u00eandice, apresento alguns fundamentos do processo de\u00a0build\u00a0do C++, fundamentais, para que voc\u00ea consiga ser “efetivo” em menos tempo, com menos chances de “atirar no pr\u00f3prio p\u00e9”. Compila\u00e7\u00e3o e linking Comecemos simples. O\u00a0build\u00a0em C++ inclui duas etapas principais: compila\u00e7\u00e3o e\u00a0linking. O processo de compila\u00e7\u00e3o processa todos os arquivos contendo c\u00f3digo-fonte individualmente e de maneira isolada. […]<\/p>\n","protected":false},"author":2,"featured_media":1981,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"hashtags":[],"tipo":[39],"url":[37],"apendices":[33],"capitulos":[],"class_list":["post-1917","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","tipo-apendice","url-permanente","apendices-apendice-a"],"_links":{"self":[{"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts\/1917","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/comments?post=1917"}],"version-history":[{"count":41,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts\/1917\/revisions"}],"predecessor-version":[{"id":1980,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts\/1917\/revisions\/1980"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/media\/1981"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/media?parent=1917"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/categories?post=1917"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/tags?post=1917"},{"taxonomy":"hashtags","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/hashtags?post=1917"},{"taxonomy":"tipo","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/tipo?post=1917"},{"taxonomy":"url","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/url?post=1917"},{"taxonomy":"apendices","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/apendices?post=1917"},{"taxonomy":"capitulos","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/capitulos?post=1917"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}