cpphead1.sct

c#设计模式WithCla

// Class: CLASS_NAME                     //ANSI C++

#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H  //Required for current class
  #define __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H

#ifndef __IOSTREAM_H            //Required for cin and cout
  #include <iostream.h>                 
#endif

[                               //Required for base classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$BASE_CLASS$_H
  #include "TRUNCATE_EIGHT$BASE_CLASS$.h"
#endif
]                               
				
[#include <INCLUDE_FILE>        //Required for include files
]                               

[                               //Required for 1:1 association classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$ASSOCIATION_ONE_CLASS$_H
  #include "TRUNCATE_EIGHT$ASSOCIATION_ONE_CLASS.h"
#endif
]                                                               

[                               //Required for 1:1 aggregation (part) classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$AGGREGATION_ONE_CLASS$_H
  #include "TRUNCATE_EIGHT$AGGREGATION_ONE_CLASS$.h"
#endif
]                                                               

[                               //Required for 1:M association classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$ASSOCIATION_MANY_CLASS$_H
  #include "TRUNCATE_EIGHT$ASSOCIATION_MANY_CLASS$.h"
#endif
]                                                               

[                               //Required for 1:M aggregation (part) classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$AGGREGATION_MANY_CLASS$_H
  #include "TRUNCATE_EIGHT$AGGREGATION_MANY_CLASS$.h"
#endif
]
          NO_OUTPUT_BEGIN Use the the CLASS_USER fields for typedef, enum, const declarations NO_OUTPUT_END
CLASS_USER1
CLASS_USER2

class CLASS_NAME[NO_RETURN NO_REPEAT: NO_REPEAT public BASE_CLASS ,DELETE_LAST_SYMBOL] CLASS_LIBRARY_BASE_CLASS     
{                       
			
  SELECT_WHEN ATTRIBUTE_ACCESS == private
  [CPP_ATTRIBUTE_STATIC ATTRIBUTE_TYPE ATTRIBUTE_NAME$; //Attribute data member]        

			
  [AGGREGATION_ONE_CLASS AGGREGATION_ONE_NAME$; //1:1 aggregation part data member]        

			
  [ASSOCIATION_ONE_CLASS$* ASSOCIATION_ONE_NAME$; //1:1 association object data member]      
			
			
  [ASSOCIATION_ONE_CLASS null$ASSOCIATION_ONE_CLASS;// Null association object for association object]      
			
			
  [int AGGREGATION_MANY_NAME$Index; //Index for array of 1:M aggregation part objects]

  [                     //1:M aggregation part data member
			//Change C array to C++ collection class with iterator
   AGGREGATION_MANY_CLASS AGGREGATION_MANY_NAME LITERAL_SYMBOL[maxNumberOf$AGGREGATION_MANY_CLASS$s LITERAL_SYMBOL];]   

			
  [int ASSOCIATION_MANY_NAME$Index; //Index for array of 1:M association objects] 
	
  [                     //1:M association object data member
			//Change C array to C++ collection class with iterator
   ASSOCIATION_MANY_CLASS$* ASSOCIATION_MANY_NAME LITERAL_SYMBOL[maxNumberOf$ASSOCIATION_MANY_CLASS$s LITERAL_SYMBOL];] 

  [                     // Null association object for initialization of association object data member
  ASSOCIATION_MANY_CLASS$ null$ASSOCIATION_MANY_CLASS;]


SELECT_WHEN OPERATION_ACCESS == private
[  CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL  ;
] 

protected:
SELECT_WHEN OPERATION_ACCESS == protected
[  CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL ;
]

SELECT_WHEN ATTRIBUTE_ACCESS == protected 
[CPP_ATTRIBUTE_STATIC ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]  

public:

  SELECT_WHEN ATTRIBUTE_ACCESS == public
  [CPP_ATTRIBUTE_STATIC ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]        

			//Default constructor alternative to compiler provided default constructor
			//Ensure correct initial values
			//Initialization list has members in the order declared
			//Association object data member pointers initialized to null association object
  CLASS_NAME () SELECT_WHEN ATTRIBUTE_IS_NORMAL [NO_RETURN NO_REPEAT: ATTRIBUTE_NAME(ATTRIBUTE_INITIAL_VALUE),DELETE_LAST_SYMBOL]
  { 
    [ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]
    [AGGREGATION_MANY_NAME$Index = 0;           //Index for array of 1:M aggregation part objects ]
    [ASSOCIATION_MANY_NAME$Index = 0;           //Index for array of 1:M association objects ]
			//Initialization of array of 1:M association objects to null association objects
    [for ( int i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS; ]
  } 

			//Constructor with arguments
			//Update to argument list to initialize base class data members, 
			//e.g. (int aNumber) : BaseClass (aNumber)
  CLASS_NAME ( SELECT_WHEN ATTRIBUTE_IS_NORMAL [NO_RETURN ATTRIBUTE_TYPE a$ATTRIBUTE_NAME,DELETE_LAST_SYMBOL] ) 
    [NO_RETURN NO_REPEAT: BASE_CLASS$() ,DELETE_LAST_SYMBOL] 
  { [AGGREGATION_MANY_NAME$Index = 0;           //Index for array of 1:M aggregation part objects ]
    [ASSOCIATION_MANY_NAME$Index = 0;           //Index for array of 1:M association objects ]
    SELECT_WHEN ATTRIBUTE_IS_NORMAL [ATTRIBUTE_NAME = a$ATTRIBUTE_NAME; ]
    [ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]
			//Initialization of array of 1:M association objects to null association objects
    [for ( int i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS; ]
  }      
  
	//Copy constructor alternative to compiler provided default copy constructor
	//Copy alternatives for association objects: (1) initialize association object to nullAssociation Object
	//(2) Shallow copy to copy pointers of association objects (3) Deep copy to create new association objects
	//and copy values of association objects
	//Commented out code assigns 1:1 and 1:M association object data member pointers for shallow copy
	//Remove // if you desire to assign pointers    
  CLASS_NAME (const CLASS_NAME$& a$CLASS_NAME ) [NO_RETURN NO_REPEAT: BASE_CLASS (a$CLASS_NAME),DELETE_LAST_SYMBOL]
  { int i = 0;
   [ AGGREGATION_MANY_NAME$Index = 0;           //Index for array of 1:M aggregation part objects ]
   [ ASSOCIATION_MANY_NAME$Index = 0;           //Index for array of 1:M association objects ]
   SELECT_WHEN ATTRIBUTE_IS_NORMAL
   [ ATTRIBUTE_NAME = a$CLASS_NAME$.$ATTRIBUTE_NAME;]
   [ AGGREGATION_ONE_NAME = a$CLASS_NAME$.$AGGREGATION_ONE_NAME;]  
   [ ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]     
   [ //ASSOCIATION_ONE_NAME = a$CLASS_NAME$.$ASSOCIATION_ONE_NAME; //Commented out shallow copy]
   [ for ( i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++) AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
   [ for ( i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS; //Initialization of pointers to 0 ]
   [ //Commented out shallow copy
   [ //for ( i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
  }                                     

	//Operator= Assignment Operator alternative to compiler provided default operator=
	//If base class make virtual
	//Assignment alternatives for association objects: (1) initialize association object to nullAssociation Object
	//(2) Shallow copy to copy pointers to association objects (3) Deep copy to create new association objects
	//and copy values of association objects
	//Commented out code assigns 1:1 association object data member pointers for shallow copy 
	//Remove // if you desire to assign association object pointers for shallow copy    
  CLASS_NAME& operator= (const CLASS_NAME$& a$CLASS_NAME);
 
			//Operator== Equality Operator - No compiler default operator== generated
			//If base class make virtual
			//Update to access 1:1 association object data members
			//Function does not compare 1:1 and 1:M association object data member pointers 
  int operator== (const CLASS_NAME$& a$CLASS_NAME) const;
	
			//Operator<< for cout
  friend ostream& operator<< (ostream& os, CLASS_NAME$& a$CLASS_NAME);

			//Operator>> for cin
  friend istream& operator>> (istream& is, CLASS_NAME$& a$CLASS_NAME);
				
SELECT_WHEN ATTRIBUTE_IS_NORMAL                 
[                       //Get accessor function for non-static attribute data member
  ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$() const
  { return ATTRIBUTE_NAME$;
  }
]                       

SELECT_WHEN ATTRIBUTE_IS_NORMAL                 
[                       //Set accessor function for non-static attribute data member
  void set$ATTRIBUTE_NAME (const ATTRIBUTE_TYPE a$ATTRIBUTE_NAME$)
  { ATTRIBUTE_NAME = a$ATTRIBUTE_NAME$;
  }
]       

SELECT_WHEN ATTRIBUTE_IS_STATIC                 
[                       //Get accessor function for static attribute data member
  static ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$()
  { return ATTRIBUTE_NAME$;
  }
]                       

SELECT_WHEN ATTRIBUTE_IS_STATIC                 
[                       //Set accessor function for static attribute data member
  static void set$ATTRIBUTE_NAME ( ATTRIBUTE_TYPE a$ATTRIBUTE_NAME$)
  { ATTRIBUTE_NAME = a$ATTRIBUTE_NAME$;
  }
]                       

[                       //Get accessor function for 1:1 aggregation part data member
  AGGREGATION_ONE_CLASS$& get$AGGREGATION_ONE_CLASS$() 
  { return AGGREGATION_ONE_NAME$;
  }
]                       
			
[                       //Set accessor function for 1:1 aggregation part data member
  void set$AGGREGATION_ONE_CLASS (AGGREGATION_ONE_CLASS$& a$AGGREGATION_ONE_NAME$)
  { AGGREGATION_ONE_NAME = a$AGGREGATION_ONE_NAME$;
  }
]

[                       //Get accessor function for 1:1 association object data member
  ASSOCIATION_ONE_CLASS$* get$ASSOCIATION_ONE_CLASS$() const
  { return ASSOCIATION_ONE_NAME$;
  }
]                       
			
[                       //Set accessor function for 1:1 association object data member
  void set$ASSOCIATION_ONE_CLASS ($ASSOCIATION_ONE_CLASS$* a$ASSOCIATION_ONE_NAME$)
  { ASSOCIATION_ONE_NAME = a$ASSOCIATION_ONE_NAME$;
  }
]

SELECT_WHEN OPERATION_ACCESS == public
[ CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL  ;
] 

  OPERATION_CPP_VIRTUAL_BASE_CLASS ~ CLASS_NAME ( ) { }  //Destructor - Delete any pointer data members that used new in constructors 
	 //Destructor should be virtual if and only if class contains at least one virtual function
	 //Objects destroyed in the reverse order ot the construction order
};

#endif