class counter; A simple counter class
{
        int TheCount; this stores the count
        int Increment; this is how much to increment the counter by
        
        constructor() : void ;is the contructor. Constucts the class. returns void/nothing
        {
                mov TheCount, 0
                mov Increment, 1
        }
        
        constructor(int increment) : void ; overloaded contructor
        {
                mov TheCount, 0
                mov Increment, increment
        }
        
        
        Increment() : void ;returns nothing
        {
                add TheCount, Increment
        }
        
        Value() : int ;returns an int
        {
                return TheCount
        }
        
        Value(int set) : void ;overloaded to set value
        {
                mov TheCount, set
        }
        
        destructor() : void ;...this is the destructor
        {
                ; doesn't do anything. No-need. 
        }
}
    

Without it, is practical making large programs in assembly? Doesn't it get all messy without the nice encapsulation OO languages offer? As a c++ programmer, you always hear that large programs in C become unmanageable as they get large – wouldn’t you get the same in assembly?

Maybe some demo of creating COM object in assembly would help

type baseClass : class
var
    i:int32;
procedure create; @returns( "esi" );
procedure geti; @returns( "eax" );
method seti( ival:int32 ); @external;
endclass;

procedure baseClass.create;
begin create;
    push( eax );
    if( esi = 0 ) then
    malloc( @size( baseClass ));
    mov( eax, esi );
endif;
mov( baseClass._VMT_, this._pVMT_ );
pop( eax );
ret();
end create;

procedure baseClass.geti; @nodisplay; @noframe;
begin geti;
    mov( this.i, eax );
    ret();
end geti;

method baseClass.seti( ival:int32 ); @nodisplay;
begin seti;
    push( eax );
    mov( ival, eax );
    mov( eax, this.i );
    pop( eax );
end seti;
    

I was wondering, would it be feasible to have object oriented assembly? I've come up with a little class using c++ish syntax.

I'm assuming all methods are private, and member variables private. For methods I use the syntax

method_name(parmaters) : returnType

Code:

class counter; A simple counter class
{
 int TheCount; this stores the count
 int Increment; this is how much to increment the counter by
 
    constructor() : void ;is the contructor. Constucts the class. returns void/nothing
      {
              mov TheCount, 0
             mov Increment, 1
    }
      
    constructor(int increment) : void ; overloaded contructor
       {
              mov TheCount, 0
             mov Increment, increment
    }
      
    
    Increment() : void ;returns nothing
     {
              add TheCount, Increment
     }
      
    Value() : int ;returns an int
   {
              return TheCount
     }
      
    Value(int set) : void ;overloaded to set value
  {
              mov TheCount, set
   }
      
    destructor() : void ;...this is the destructor
  {
              ; doesn't do anything. No-need.        
    }
}
    

Anyone got any thoughts?

struc counter {
      .TheCount dd ?
      .Increment dd ?

      proc .constructor
           mov [.TheCount], 0
           mov [.Increment], 1
      ret
      endp

      proc .IncrementCount
           mov eax,[.Increment]
           add [.TheCount],eax
      ret
      endp
}