• Create Account

### #ActualCosmic314

Posted 11 September 2013 - 02:48 PM

Is the allocator parameter of C++ standard library containers an example of the strategy pattern? It customizes the logic based off of the allocator passed in, without changing the functionality of the container itself.

Yeah, I think that's about right.

In my listen() example, my creature class might implement it as a giant series of if/then/else statements every single time I call listen, even though the state of the creature rarely changes.  Rather than have a giant sequence of if/then/elses I could instead pay that cost one time.  For example when the creature goes deaf I can change the listen() strategy to the deaf strategy, which still happens to use the same interface.  Now I have tidier code.  If I call listen() a zillion times, I save a bundle of branch instructions on that if/then/else tree.  Pardon my poor syntax below, but it's enough to get the idea across (I hope!)

void creature_class::listen()
{
this->InterfaceListen_strategy->execute();
// place this creature's specific code afterwards, if any, that is invariant
}

void creature_class::set_listen_strategy( <variables> )
{
if( DEAF ) this->IntefaceListenStrategy = DeafListenConcrete;
if( BUFFED ) this->IntefaceListenStrategy = BuffedListenConcrete;
// etc.
}



### #4Cosmic314

Posted 11 September 2013 - 02:43 PM

Is the allocator parameter of C++ standard library containers an example of the strategy pattern? It customizes the logic based off of the allocator passed in, without changing the functionality of the container itself.

Yeah, I think that's about right.

In my listen() example, my creature class might implement it as a giant series of if/then/else statements every single time I call listen, even though the state of the creature rarely changes.  Rather than have a giant sequence of if/then/elses I could instead pay that cost one time.  For example when the creature goes deaf I can change the listen() strategy to the deaf strategy, which still happens to use the same interface.  Now I have tidier code.  If I call listen() a zillion times, I save a bundle of branch instructions on that if/then/else tree.  Pardon my poor syntax below, but it's enough to get the idea across (I hope!)

void creature_class::listen()
{
this->InterfaceListen_strategy->execute();
// place this creature's specific code afterwards, if any
}

void creature_class::set_listen_strategy( <variables> )
{
if( DEAF ) this->IntefaceListenStrategy = DeafListenConcrete;
if( BUFFED ) this->IntefaceListenStrategy = BuffedListenConcrete;
// etc.
}



### #3Cosmic314

Posted 11 September 2013 - 02:42 PM

Is the allocator parameter of C++ standard library containers an example of the strategy pattern? It customizes the logic based off of the allocator passed in, without changing the functionality of the container itself.

Yeah, I think that's about right.

In my listen() example, my creature class might implement it as a giant series of if/then/else statements every single time I call listen, even though the state of the creature rarely changes.  Rather than have a giant sequence of if/then/elses I could instead pay that cost one time.  For example when the creature goes deaf I can change the listen() strategy to the deaf strategy, which still happens to use the same interface.  Now I have tidier code.  If I call listen() a zillion times, I save a bundle of branch instructions on that if/then/else tree.  Pardon my poor syntax below, but it's enough to get the idea across (I hope!)

void creature_class::listen()
{
this->InterfaceListen_strategy->execute();
<place this creature's specific code afterwards, if any>
}

void creature_class::set_listen_strategy( <variables> )
{
if( DEAF ) this->IntefaceListenStrategy = DeafListenConcrete;
if( BUFFED ) this->IntefaceListenStrategy = BuffedListenConcrete;
// etc.
}



### #2Cosmic314

Posted 11 September 2013 - 02:35 PM

Is the allocator parameter of C++ standard library containers an example of the strategy pattern? It customizes the logic based off of the allocator passed in, without changing the functionality of the container itself.

Yeah, I think that's about right.

In my listen() example, my creature class might implement it as a giant series of if/then/else statements every single time I call listen, even though the state of the creature rarely changes.  Rather than have a giant sequence of if/then/elses I could instead pay that cost one time.  For example when the creature goes deaf I can change the listen() strategy to the deaf strategy, which still happens to use the same interface.  Now I have tidier code.  If I call listen() a zillion times, I save a bundle of branch instructions on that if/then/else tree.  Pardon my poor syntax below, but it's enough to get the idea across (I hope!)

void creature_class::listen()
{
this->InterfaceListen_strategy->execute();
}

void creature_class::set_listen_strategy( <variables> )
{
if( DEAF ) this->IntefaceListenStrategy = DeafListenConcrete;
if( BUFFED ) this->IntefaceListenStrategy = BuffedListenConcrete;
// etc.
}



### #1Cosmic314

Posted 11 September 2013 - 02:34 PM

Is the allocator parameter of C++ standard library containers an example of the strategy pattern? It customizes the logic based off of the allocator passed in, without changing the functionality of the container itself.

Yeah, I think that's about right.

In my listen() example, my creature class might implement it as a giant series of if/then/else statements every single time i call listen, even though the state of the creature rarely changes.  Rather than have a giant sequence of if/then/elses I could instead pay that cost one time.  For example when the creature goes deaf I can change the listen() strategy to the deaf strategy, which still happens to use the same interface.  Now I have tidier code.  If I call listen() a zillion times, I save a bundle of branch instructions on that if/then/else tree.  Pardon my poor syntax below, but it's enough to get the idea across (I hope!)

void creature_class::listen()
{
this->InterfaceListen_strategy->execute();
}

void creature_class::set_listen_strategy( <variables> )
{
if( DEAF ) this->IntefaceListenStrategy = DeafListenConcrete;
if( BUFFED ) this->IntefaceListenStrategy = BuffedListenConcrete;
// etc.
}



PARTNERS