{"id":2036,"date":"2022-03-08T23:37:52","date_gmt":"2022-03-09T02:37:52","guid":{"rendered":"https:\/\/elemarjr.com\/cppmoderno\/?p=2036"},"modified":"2025-06-18T16:07:07","modified_gmt":"2025-06-18T19:07:07","slug":"evitando-efeitos-colaterais-indesejaveis-com-const-correctness-apendice-c-v-1-0","status":"publish","type":"post","link":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/evitando-efeitos-colaterais-indesejaveis-com-const-correctness-apendice-c-v-1-0\/","title":{"rendered":"Evitando “efeitos colaterais indesej\u00e1veis” com “const correctness” \/ Ap\u00eandice C v 1.0"},"content":{"rendered":"

Poucas linguagens permitem ao programador expressar suas inten\u00e7\u00f5es, manipulando dados em mem\u00f3ria, com tanta riqueza quanto C++.<\/strong> Exemplo disso, \u00e9 uma funcionalidade da linguagem, extremamente poderosa, ausente na maioria das linguagens\u00a0mainstream<\/em>, conhecida como const correctness.<\/em><\/p>\n

Mais do mesmo…<\/h2>\n

Para entender o poder de\u00a0const correctness<\/em>, vamos, antes, revisitar duas features <\/em>mais simples, comuns a quase todas as linguagens: passagem de par\u00e2metros “por valor” e “por refer\u00eancia”<\/strong><\/p>\n

No exemplo que segue, uma\u00a0string <\/em>\u00e9 passada “por valor”. Ou seja, um “objeto-c\u00f3pia” \u00e9 criado quando a fun\u00e7\u00e3o \u00e9 acionada e destru\u00eddo no momento em que ela retorna.<\/p>\n

#include <iostream>\r\n#include <string>\r\n\r\n\/\/ s is passed by value\r\nvoid f(std::string s) {\r\n  s.clear();\r\n  std::cout << \"F: S is empty: \" << s.empty() << std::endl;\r\n}\r\n\r\nint main() {\r\n  std::string s(\"This is my string\");\r\n  f(s);\r\n  std::cout << \"main: S is empty: \" << s.empty() << std::endl;\r\n  std::cout << \"main: S value   : \" << s << std::endl;\r\n  return 0;\r\n}\r\n\r\n\/\/ OUTPUT\r\n\/\/ F: S is empty   : 1\r\n\/\/ main: S is empty: 0\r\n\/\/ main: S value   : This is my string\r\n<\/pre>\n
O resultado desse c\u00f3digo \u00e9 que a string<\/em> original, criada na\u00a0fun\u00e7\u00e3o main<\/code>, permanece seguramente inalterada, enquanto uma nova string<\/em> \u00e9 manipulada na fun\u00e7\u00e3o f<\/code> .<\/p>\n
J\u00e1 no exemplo que segue, \u00e9 indicado que o valor recebido como par\u00e2metro \u00e9 passado “por refer\u00eancia”.<\/p>\n
#include <iostream>\r\n#include <string>\r\n\r\n\/\/ s is a reference\r\nvoid f(std::string& s) {\r\n  s.clear();\r\n  std::cout << \"F: S is empty: \" << s.empty() << std::endl;\r\n}\r\n\r\nint main() {\r\n  std::string s(\"This is my string\");\r\n  f(s);\r\n  std::cout << \"main: S is empty: \" << s.empty() << std::endl;\r\n  std::cout << \"main: S value   : \" << s << std::endl;\r\n  return 0;\r\n}\r\n\r\n\/\/ OUTPUT\r\n\/\/ F: S is empty   : 1\r\n\/\/ main: S is empty: 1\r\n\/\/ main: S value   : \r\n<\/pre>\n
O resultado do c\u00f3digo acima \u00e9 que a string<\/em> original, criada na\u00a0fun\u00e7\u00e3o main<\/code>, \u00e9 a mesma recebida e manipulada na fun\u00e7\u00e3o f<\/code> .<\/p>\n
Um problema quase sem solu\u00e7\u00e3o, fora do C++<\/h2>\n
Como previnir que um programador realize altera\u00e7\u00f5es, inadvertidamente, no estado de um objeto passado como par\u00e2metro “por refer\u00eancia”?\u00a0<\/strong>Em C++, basta marcar tal par\u00e2metro como const<\/code>.<\/p>\n
#include <iostream>\r\n#include <string>\r\n\r\n\/\/ s is a reference\r\nvoid f(const std::string& s) {\r\n  s.clear();\r\n  std::cout << \"F: S is empty: \" << s.empty() << std::endl;\r\n}\r\n\r\nint main() {\r\n  std::string s(\"This is my string\");\r\n  f(s);\r\n  std::cout << \"main: S is empty: \" << s.empty() << std::endl;\r\n  std::cout << \"main: S value   : \" << s << std::endl;\r\n  return 0;\r\n}\r\n<\/pre>\n
O que acontece aqui \u00e9 uma esp\u00e9cie de “casting<\/em>” do tipo do objeto passado como par\u00e2metro, onde todos os membros n\u00e3o marcados como const<\/code> tornam-se inacess\u00edveis. Qualquer viola\u00e7\u00e3o \u00e9 detectada em tempo de compila\u00e7\u00e3o, sem preju\u00edzos de performance em tempo de execu\u00e7\u00e3o.<\/p>\n
Como o programador expressa “membros const<\/code>” em seus tipos<\/h2>\n
Cabe ao programador, nas suas implementa\u00e7\u00f5es de tipos, como a indicada no exemplo que segue, apontar, ent\u00e3o, os membros que n\u00e3o realizam modifica\u00e7\u00f5es de estado (seguras para serem chamadas com const<\/em>).<\/p>\n
class Person {\r\n  int _age {};\r\npublic:\r\n  auto age() const { return _age; }       \/\/ this method is not allowed to mutate the object.\r\n  auto set_age(int age) { _age = age; }\r\n};\r\n<\/pre>\n
No exemplo acima, a implementa\u00e7\u00e3o do m\u00e9todo age<\/code>, marcado com o modificador const<\/code>, cumpre o contrato de n\u00e3o gerar modifica\u00e7\u00f5es de estado, afinal, apenas retorna um valor.<\/p>\n
class Person {\r\n  int _age {};\r\n  int _readcount{};\r\npublic:\r\n  auto age() const {\r\n    _readcount++; \r\n    return _age; \r\n  }\r\n  auto set_age(int age) { _age = age; }\r\n};\r\n<\/pre>\n
J\u00e1 o c\u00f3digo acima n\u00e3o ir\u00e1 compilar porque o compilador consegue identificar que o “compromisso” assumido no contrato (interface p\u00fablica da classe) n\u00e3o foi respeitado.<\/p>\n
Como o programador expressa “retornos const<\/code>“<\/h2>\n
Caso o valor retornado seja uma refer\u00eancia, tamb\u00e9m \u00e9 poss\u00edvel determinar se ela poder\u00e1, ou n\u00e3o, ser modificada.<\/p>\n
class Point2\r\n{\r\n  int _x;\r\n  int _y;\r\npublic:\r\n  Point2(int x, int y) : _x(x), _y(y) {}\r\n  auto x() const { return _x; }\r\n  auto set_x(int x) { _x = x; }\r\n  auto y() const { return _y; }\r\n  auto set_y(int y) { _y = y; }\r\n};\r\n\r\nclass Circle\r\n{\r\n  Point2 _center;\r\n  double _radius;\r\npublic:\r\n  Circle(int centerX, int centerY, double radius) :\r\n    _center(Point2(centerX, centerY)), _radius(radius) {}\r\n\r\n  auto& center() const { return _center; };\r\n  auto radius() const { return _radius; };\r\n};\r\n<\/pre>\n
No c\u00f3digo acima, por exemplo, o getter<\/em> center<\/code> retorna uma refer\u00eancia “constante” para um objeto do tipo Point2<\/code>, evitando, com toda a seguran\u00e7a, a cria\u00e7\u00e3o de uma “c\u00f3pia” na mem\u00f3ria.<\/p>\n
int main()\r\n{\r\n    Circle c(11, 0, 10.0);\r\n    c.center().set_y(10); \/\/ will not compile, set_y requires a mutable object.\r\n    return 0;\r\n}\r\n<\/pre>\n
O exemplo acima, n\u00e3o ir\u00e1 compilar porque h\u00e1 uma tentativa de acessar um membro “n\u00e3o-const” em um tipo indicado como “const”.<\/p>\n
O compilador do C++ n\u00e3o ajuda?<\/h2>\n
Para cumprir seu compromisso de conceder ao programador o m\u00e1ximo de acesso a recursos, para obten\u00e7\u00e3o de performance \u00f3tima, em um tempo em que compiladores dispunham de poucos KB para processar bases gigantescas de c\u00f3digo, C++ j\u00e1 permitiu (e por compatibilidade retroativa, ainda permite) a escrita de c\u00f3digo “perigoso”. Entretanto, a linguagem amadureceu e hoje oferece artif\u00edcios simples para impedir grandes enganos. Um desses artif\u00edcios \u00e9 a ideia de “const correctness<\/em>“.<\/strong><\/p>\n
Trata-se de uma solu\u00e7\u00e3o genialmente simples para impedir enganos perigosos, simplesmente permitindo que o programador expresse o que deseja do c\u00f3digo de maneira cuidadosa. O compilador do C++ n\u00e3o ajuda “direcionando” o programador para “n\u00e3o enganos”, mas garantindo que suas inten\u00e7\u00f5es, expressas no c\u00f3digo, sejam concretizadas.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
Poucas linguagens permitem ao programador expressar suas inten\u00e7\u00f5es, manipulando dados em mem\u00f3ria, com tanta riqueza quanto C++. Exemplo disso, \u00e9 uma funcionalidade da linguagem, extremamente poderosa, ausente na maioria das linguagens\u00a0mainstream, conhecida como const correctness. Mais do mesmo… Para entender o poder de\u00a0const correctness, vamos, antes, revisitar duas features mais simples, comuns a quase todas […]<\/p>\n","protected":false},"author":2,"featured_media":2068,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"hashtags":[],"tipo":[39],"url":[],"apendices":[35],"capitulos":[],"class_list":["post-2036","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","tipo-apendice","apendices-apendice-c"],"_links":{"self":[{"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts\/2036","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=2036"}],"version-history":[{"count":35,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts\/2036\/revisions"}],"predecessor-version":[{"id":2076,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/posts\/2036\/revisions\/2076"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/media\/2068"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/media?parent=2036"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/categories?post=2036"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/tags?post=2036"},{"taxonomy":"hashtags","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/hashtags?post=2036"},{"taxonomy":"tipo","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/tipo?post=2036"},{"taxonomy":"url","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/url?post=2036"},{"taxonomy":"apendices","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/apendices?post=2036"},{"taxonomy":"capitulos","embeddable":true,"href":"https:\/\/elemarjr.com\/livros\/cpp-moderno\/wp-json\/wp\/v2\/capitulos?post=2036"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}