AVR Freaks

You need to go further-

https://github.com/cv007/ATmega4...

#include "Port.hpp"

int main(){
    Port< Pins::PF4, Pins::OUTH > led;      //output, high is on
    Port< Pins::PF6, Pins::INLPU > button;  //input, low is on, pullup on

    //or with pin types already created (in "Port.hpp")
    //PF4_OUTH_t led;
    //PF6_INLPU_t button; 

    for(;;){
        led.on( button.ison() );
    }

}

000000f4 <main>:
  f4:    10 92 b4 04     sts    0x04B4, r1    ; 0x8004b4 <__TEXT_REGION_LENGTH__+0x7f44b4>
  f8:    ac 98           cbi    0x15, 4    ; 21
  fa:    a4 9a           sbi    0x14, 4    ; 20

  fc:    88 e8           ldi    r24, 0x88    ; 136
  fe:    80 93 b6 04     sts    0x04B6, r24    ; 0x8004b6 <__TEXT_REGION_LENGTH__+0x7f44b6>
 102:    a6 98           cbi    0x14, 6    ; 20

 104:    b6 9b           sbis    0x16, 6    ; 22
 106:    02 c0           rjmp    .+4          ; 0x10c <__EEPROM_REGION_LENGTH__+0xc>
 108:    ac 9a           sbi    0x15, 4    ; 21
 10a:    fc cf           rjmp    .-8          ; 0x104 <__EEPROM_REGION_LENGTH__+0x4>
 10c:    ac 98           cbi    0x15, 4    ; 21
 10e:    fa cf           rjmp    .-12         ; 0x104 <__EEPROM_REGION_LENGTH__+0x4>

Let the constructor handle setting up the pin as you describe with the Port template parameters. Forget all the pointers, etc.- that just replaces the C world usage with similar C++ usage, and nothing much is gained.

The template usage is almost required on the 8bit avr for pins (and other things), because when using a 'normal' class for pins the pointer usage behind the scenes starts to look pretty bad (in comparison to template use anyway). For a 32bit mcu, getting along without templates is easier as the little extra code size and storage are probably worth it, and the resulting pointer usage is simple and straight forward.

When using the avr Port class, the template parameters are 'dragged' along everywhere they go, so the compiler knows everything it needs to know just by the use of an instantiated Port class. So what looks like could be a lot of code, turns out to be as little as anything else because the compiler has all it needs to know and can reduce it to the very simple.

You don't even have to instantiate the class- if you want a pullup on for PA1, just do-  

PA1_t::pullup( true ); //or

Port< Pins::PA1 >::pullup( true ); //same thing

since the pullup function does not need to know whether input/output/etc., can just use the basic info which is the pin name only. Every function is a static function so can be called directly if wanted.

(I also have a simulated open-drain mode, which is also taken care of automatically)

There are many nice things in C++, and you don't even have to use that many features to start realizing benefits. The first major benefit is you can start to do away with defines and start dealing with the compiler directly.