{"id":1435,"date":"2021-11-27T22:01:20","date_gmt":"2021-11-27T21:01:20","guid":{"rendered":"https:\/\/www.blauringlabs.com\/?p=1435"},"modified":"2023-01-23T18:31:41","modified_gmt":"2023-01-23T17:31:41","slug":"law-of-demeter-principle-of-least-knowledge","status":"publish","type":"post","link":"https:\/\/www.blauringlabs.com\/en\/law-of-demeter-principle-of-least-knowledge\/","title":{"rendered":"Law of Demeter or Principle of Least Knowledge"},"content":{"rendered":"

One of the classical as well as mainly ignored principles of software engineering is the Principle of Least Knowledge aka Law of Demeter<\/em>. There is many academical essays in the web about this, but the main point it\u2019s not so easy to grasp in my opinion, so I\u2019ll give a shot in explaining this concept from a developer perspective.<\/p>\n

Imagine a class Customer<\/em> that offers a pointer to class Wallet<\/em>, so for each payment, the Customer just delegates into Wallet<\/em>.<\/p>\n

\n
\n
class<\/span> Customer<\/span> \n{<\/span>\npublic:<\/span>\nCustomer<\/span>()<\/span> {<\/span>\n        myWallet<\/span> =<\/span> new<\/span> Wallet<\/span>();<\/span>\n        myWallet<\/span>-><\/span>addMoney<\/span>(<\/span>200<\/span>);<\/span>\n }<\/span>\n\n~<\/span>Customer<\/span>(){<\/span>  delete<\/span> myWallet<\/span>;<\/span> }<\/span>\n\nWallet<\/span>*<\/span> getWallet<\/span>()<\/span> {<\/span> return<\/span> myWallet<\/span>;<\/span> }<\/span>\n\nprivate:<\/span>\n    Wallet<\/span>*<\/span> myWallet<\/span>;<\/span>\n};<\/span>\n<\/code><\/pre>\n<\/div>\n<\/div>\n
and the class Wallet takes care of the cash by itself:<\/p>\n
\n
\n
class<\/span> Wallet<\/span> \n{<\/span>\npublic:<\/span>\n    Wallet<\/span>()<\/span>\n    :<\/span>currentMoney<\/span>(<\/span>0<\/span>)<\/span>\n    {}<\/span>\n\n    void<\/span> addMoney<\/span>(<\/span>int<\/span> amount<\/span>)<\/span> {<\/span>\n        currentMoney<\/span> +=<\/span> amount<\/span>;<\/span>\n    }<\/span>\n\n    const<\/span> int<\/span> howMuchMoney<\/span>()<\/span> {<\/span>\n        return<\/span> currentMoney<\/span>;<\/span>\n    }<\/span>\n\n    int<\/span> retrieveMoney<\/span>(<\/span>int<\/span> amount<\/span>)<\/span> {<\/span>\n       int<\/span> moneyTaken<\/span>;<\/span>\n       if<\/span> (<\/span>amount<\/span> <=<\/span> currentMoney<\/span>)<\/span> {<\/span>\n           moneyTaken<\/span> =<\/span> amount<\/span>;<\/span>\n           currentMoney<\/span> -=<\/span> amount<\/span>;<\/span>\n       }<\/span>\n       else<\/span> {<\/span>\n           moneyTaken<\/span> =<\/span> currentMoney<\/span>;<\/span>\n           currentMoney<\/span> =<\/span> 0<\/span>;<\/span>\n       }<\/span>\n       return<\/span> moneyTaken<\/span>;<\/span>\n    }<\/span>\n\nprivate:<\/span>\n    int<\/span> currentMoney<\/span>;<\/span>\n};<\/span>\n<\/code><\/pre>\n<\/div>\n<\/div>\n
For each payment, Customer<\/em> just delegates to Wallet<\/em>, as you see in the following lines:<\/p>\n
\n
\n
int<\/span> main<\/span>()<\/span>\n\n{<\/span>\n\nCustomer<\/span> customer<\/span>;<\/span>\nint<\/span>  customerMoney<\/span> =<\/span> customer<\/span>.<\/span>getWallet<\/span>()<\/span>-><\/span>howMuchMoney<\/span>();<\/span>\n\nstd<\/span>::<\/span>cout<\/span> <<<\/span> \"Money, \"<\/span> <<<\/span> customerMoney<\/span> <<<\/span> \"!<\/span>\\n<\/span>\"<\/span>;<\/span> \/\/ Money, 200!<\/span>\n\n\/\/Buy<\/span>\nbool<\/span> waspaid<\/span> =<\/span> customer<\/span>.<\/span>getWallet<\/span>()<\/span>-><\/span>retrieveMoney<\/span>(<\/span>3<\/span>);<\/span>\n\nstd<\/span>::<\/span>cout<\/span> <<<\/span> \"paid, \"<\/span> <<<\/span> (<\/span>waspaid<\/span>?<\/span>\"yes\"<\/span>:<\/span>\"no\"<\/span>)<\/span> <<<\/span> \"!<\/span>\\n<\/span>\"<\/span>;<\/span> \/\/paid, yes!<\/span>\nstd<\/span>::<\/span>cout<\/span> <<<\/span> \"current Money, \"<\/span> <<<\/span> customer<\/span>.<\/span>getWallet<\/span>()<\/span>-><\/span>howMuchMoney<\/span>()<\/span> <<<\/span> \"!<\/span>\\n<\/span>\"<\/span>;<\/span> \n\/\/current Money, 197!<\/span>\n\n}<\/span>\n<\/code><\/pre>\n<\/div>\n<\/div>\n
So far so good. By just calling customer.getWallet()<\/em> class Customer shifts the work to Wallet<\/em>. As Wallet<\/em> know how to deal with the cash flow, all is well.<\/p>\n
Well?, well, let\u2019s say in an update, Customer<\/em> has to deal with 2 Wallets (I\u2019m old enough to remember the times before \u20ac, when I had to carry 2 wallets around, one with Spanish Pesetas and other with German D-Marks. Fortunately not anymore). Translating that to our code, it means the Customer<\/em> need a second instance of Wallet<\/em>, a situation we can code like this:<\/p>\n
\n
\n
class<\/span> Customer<\/span> {<\/span>\n\npublic:<\/span>\n    Customer<\/span>()<\/span> {<\/span>\n        myWallets<\/span>.<\/span>push_back<\/span>(<\/span>new<\/span> Wallet<\/span>());<\/span>\n        myWallets<\/span>.<\/span>push_back<\/span>(<\/span>new<\/span> Wallet<\/span>());<\/span>\n        myWallets<\/span>[<\/span>0<\/span>]<\/span>-><\/span>addMoney<\/span>(<\/span>200<\/span>);<\/span>\n        myWallets<\/span>[<\/span>1<\/span>]<\/span>-><\/span>addMoney<\/span>(<\/span>50<\/span>);<\/span>\n    }<\/span>\n\n~<\/span>Customer<\/span>(){<\/span>\n  for<\/span> (<\/span>std<\/span>::<\/span>vector<\/span><<\/span>Wallet<\/span>*>::<\/span>iterator<\/span> it<\/span> =<\/span> myWallets<\/span>.<\/span>begin<\/span>()<\/span> ;<\/span> it<\/span> !=<\/span> myWallets<\/span>.<\/span>end<\/span>();<\/span> ++<\/span>it<\/span>)<\/span>\n     delete<\/span>(<\/span>*<\/span>it<\/span>);<\/span>\n}<\/span>\n\nWallet<\/span>*<\/span> getWallet<\/span>(<\/span>unsigned<\/span> int<\/span> pos<\/span>)<\/span> {<\/span>\n        if<\/span> (<\/span>pos<\/span> <<\/span> 2<\/span>)<\/span>\n            return<\/span> myWallets<\/span>[<\/span>pos<\/span>];<\/span>\n        else<\/span>\n            return<\/span> NULL<\/span>;<\/span>\n        }<\/span>\n\nprivate:<\/span>\n       std<\/span>::<\/span>vector<\/span><<\/span>Wallet<\/span>*><\/span> myWallets<\/span>;<\/span>\n};<\/span>\n<\/code><\/pre>\n<\/div>\n<\/div>\n
But now, the code inside Main() is broken. We need to rewrite it and tell which Wallet<\/em> to get the money from.<\/p>\n
\n
\n
int<\/span> main<\/span>()<\/span>\n{<\/span>\n  Customer<\/span> customer<\/span>;<\/span>\n  int<\/span> customerMoney<\/span> =<\/span> customer<\/span>.<\/span>getWallet<\/span>(<\/span>0<\/span>)<\/span>-><\/span>getCurrentMoney<\/span>();<\/span>\n  std<\/span>::<\/span>cout<\/span> <<<\/span> \"Money, \"<\/span> <<<\/span> customerMoney<\/span> <<<\/span> \"!<\/span>\\n<\/span>\"<\/span>;<\/span> \/\/Money, 200!<\/span>\n}<\/span>\n<\/code><\/pre>\n<\/div>\n<\/div>\n
You can imagine that all<\/strong> places where customer.GetWallet()<\/em> is invoked now need correction. And depending of your code, this can be a lot of work. It\u2019s even worse if Customer<\/em> is shipped as part of a library and you have no access to the code which makes use of the Wallet<\/em>.<\/p>\n
This is not only a design flow, but sometimes also a security issue. You cannot assume that clients use your API in the way you expect:<\/p>\n
\n
\n
int<\/span> main<\/span>()<\/span>\n{<\/span>\n  \/\/Opps!<\/span>\n  Customer<\/span>*<\/span> victim<\/span> =<\/span> &<\/span>customer<\/span>;<\/span>\n  victim<\/span>-><\/span>getWallet<\/span>()<\/span>-><\/span>retrieveMoney<\/span>(<\/span>victim<\/span>-><\/span>getWallet<\/span>()<\/span>-><\/span>howMuchMoney<\/span>());<\/span>\n  std<\/span>::<\/span>cout<\/span> <<<\/span> \"Money left?, \"<\/span> <<<\/span> victim<\/span>-><\/span>getWallet<\/span>()<\/span>-><\/span>howMuchMoney<\/span>()<\/span> <<<\/span> \"!<\/span>\\n<\/span>\"<\/span>;<\/span> \n  \/\/Money left?, 0!<\/span>\n}<\/span>\n<\/code><\/pre>\n<\/div>\n<\/div>\n
But wait a second, why should Main()<\/em> have to choose between wallets? Why should it know that there are two? This imply a level of knowledge that no one from outside Customer<\/em> class should know. What\u2019s the problem here?<\/p>\n