doxygen -g
doxygen

Example :


/**
   @class MyExprTree
   @brief My brief one line comment

   The MyClassName class represents a node in an expression tree.
   This node can be a column reference, a constant value, a host
   parameter, or an operator.

   @note This class is never instantiated by the wrapper.
*/
class MyExprTree : public SomeClass {
public:
  /**
    @brief Kind of Request_Exp node
        This is used in many places.
  */
  enum kind
  {
    column,   /**< Node represents a column reference */
    constant, /**< Node represents a constant value */
    oper      /**< Node represents an operator and has child Request_Exp nodes */
  };

  //**** start of the interface used by the wrapper writer ****

  /**
    @brief Retrieve kind of a Request_Exp node

    @warning This function is deprecated.

    @param a_request [in]
      Request object the Request_Exp tree belongs to. Can be null.

    @param a_kind [out]
      Request_Exp node kind

    @retval 0 Success
    @retval SQLQG_ERROR Error
  */
  Sqlqg_Return_Code        get_kind (Request*   a_request,
                                     kind*      a_kind);


  /** @brief Pointer to optqtb pointer */
  sqlno_qtb*          m_optqtbP;

  // Note: The second line to @brief is a detailed description

  /** @brief Pointer to array of Request_Exp trees representing predicates.
             Array uses same index as corresponding entry in m_preds */
  class Request_Exp** m_pred_rexps;

}



Use \ or @ :

    * \struct to document a C-struct.
    * \union to document a union.
    * \enum to document an enumeration type.
    * \fn to document a function.
    * \var to document a variable or typedef or enum value.
    * \def to document a #define.
    * \typedef to document a type definition.
    * \file to document a file.
    * \namespace to document a namespace.
    * \package to document a Java package.
    * \interface to document an IDL interface.

Let's repeat that, because it is often overlooked: 
   to document global objects (functions, typedefs, enum, macros, etc),
 you must document the file in which they are defined. 
In other words, there must at least be a

/*! \file */ or a /** @file */ line in this file.


If you like to declare and document separately do this:

Here is an example of a C header named structcmd.h that is documented using structural commands:

/*! \file structcmd.h
    \brief A Documented file.
    
    Details.
*/

/*! \def MAX(a,b)
    \brief A macro that returns the maximum of \a a and \a b.
   
    Details.
*/

/*! \var typedef unsigned int UINT32
    \brief A type definition for a .
    
    Details.
*/

/*! \var int errno
    \brief Contains the last error code.

    \warning Not thread safe!
*/

/*! \fn int open(const char *pathname,int flags)
    \brief Opens a file descriptor.

    \param pathname The name of the descriptor.
    \param flags Opening flags.
*/

/*! \fn int close(int fd)
    \brief Closes the file descriptor \a fd.
    \param fd The descriptor to close.
*/

/*! \fn size_t write(int fd,const char *buf, size_t count)
    \brief Writes \a count bytes from \a buf to the filedescriptor \a fd.
    \param fd The descriptor to write to.
    \param buf The data buffer to write.
    \param count The number of bytes to write.
*/

/*! \fn int read(int fd,char *buf,size_t count)
    \brief Read bytes from a file descriptor.
    \param fd The descriptor to read from.
    \param buf The buffer to read into.
    \param count The number of bytes to read.
*/

#define MAX(a,b) (((a)>(b))?(a):(b))
typedef unsigned int UINT32;
int errno;
int open(const char *,int);
int close(int);
size_t write(int,const char *, size_t);
int read(int,char *,size_t);



\code
Starts a block of code. A code block is treated differently from ordinary text. It is interpreted as C/C++ code. The names of the classes and members that are documented are automatically replaced by links to the documentation.

See also:
    section \endcode, section \verbatim.

\anchor <word>
This command places an invisible, named anchor into the documentation to which you can refer with the \ref command.

Using Links:   \link  click here:  #Var \endlink

/*! \file autolink.cpp
  Testing automatic link generation.
  
  A link to a member of the Test class: Test::member, 
  
  More specific links to the each of the overloaded members:
  Test::member(int) and Test#member(int,int)

  A link to a protected member variable of Test: Test#var, 

  A link to the global enumeration type #GlobEnum.
 
  A link to the define #ABS(x).
  
  A link to the destructor of the Test class: Test::~Test, 
  
  A link to the typedef ::B.
 
  A link to the enumeration type Test::EType
  
  A link to some enumeration values Test::Val1 and ::GVal2
*/

/*!
  Since this documentation block belongs to the class Test no link to 
  Test is generated.

  Two ways to link to a constructor are: #Test and Test().

  Links to the destructor are: #~Test and ~Test().
  
  A link to a member in this class: member().



@todo
@warning
@version
@see
@test  <include a test case description>
@pre   <pre condition>
@param
@details  (by default it follows after @brief line)
@date 
@author
@example  example1.c  example1.h
@callgraph
@callergraph