AfxGetApp() ; 

 
CWinApp* AfxGetApp( ); 

AfxGetApp()->m_lpCmdLine

AfxGetAppName() ;
// ou 
AfxGetApp()->m_pszAppName

// trouver le nom (uniquement) de l'executable
void GetNom(char *nom, DWORD taille)
{
char *c;
c = nom + GetModuleFileName(NULL,nom,taille);
while(*c!='\\') c--;
strcpy(nom,++c);
}

// trouver le nom (uniquement) de l'executable (CString)
CString CGetNom(char *nom, DWORD taille)
{
GetModuleFileName(NULL,nom,taille);
CString Cnom(nom);
return Cnom.Mid(Cnom.ReverseFind('\\')+1);
}

char nom[MAX_PATH];
GetNom(nom,MAX_PATH);

// ou
char nom[MAX_PATH];
CString Cnom = CGetNom(nom, MAX_PATH);

// trouver le chemin (uniquement) de l'application
void GetChemin(char *chemin, DWORD taille)
{
char *c;
c = chemin + GetModuleFileName(NULL,chemin,taille);
while(*c!='\\')
c--;
*c=0;
}

// trouver le chemin (uniquement) de l'application (CString)
CString CGetChemin(char *chemin, DWORD taille)
{
GetModuleFileName(NULL,chemin,taille);
CString Cchemin(chemin);
return Cchemin.Mid(0,Cchemin.ReverseFind('\\'));
}

char chemin[MAX_PATH];
GetChemin(chemin, MAX_PATH);

// ou
CString Cchemin = CGetChemin(chemin, MAX_PATH);
AfxMessageBox(Cchemin);

// a rajouter pour la définition 
#include <afxpriv.h> 

pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
AfxSetWindowText(m_pMainWnd->m_hWnd,"TestSDI- Farscape");    

m_nCmdShow = SW_SHOWMAXIMIZED ;
m_pMainWnd->ShowWindow(m_nCmdShow);
m_pMainWnd->UpdateWindow();

CWnd* AfxGetMainWnd( );

CMyMainFrame *p=(CMyMainFrame *)AfxGetMainWnd() ;

CWinApp* pApp = AfxGetApp();        
// parcourir tous les templates
CDocTemplate* pTemplate;
POSITION pos = pApp->GetFirstDocTemplatePosition();
while (pos != NULL)
{
    pTemplate = pApp->GetNextDocTemplate(pos);
    ASSERT(pTemplate);

    // tous les documents du template.
    POSITION pos2 = pTemplate->GetFirstDocPosition();
    while (pos2)
    {
        CDocument* pDoc = pTemplate->GetNextDoc(pos2);
        ASSERT(pDoc);

        // toutes les vues du document
        POSITION pos3 = pDoc->GetFirstViewPosition();
        while (pos3 != NULL)
        {
            CView* pView = pDoc->GetNextView(pos3);
            ASSERT(pView);
            if (::IsWindow(pView->GetSafeHwnd()))
            {
                if(pView->IsKindOf(RUNTIME_CLASS(CFormView)))
                {
                // une forme view
                }
                else
                if(pView->IsKindOf(RUNTIME_CLASS(CScrollView)))
                {
                // une  Scrollview
                }
                else
                if(pView->IsKindOf(RUNTIME_CLASS(CView)))
                {
                    // une  view
                }
            }
        }
    }
}

// déclaration d'une section TestApp

#pragma data_seg("TestApp") 

// la variable commune a tous les process
LONG nCtApp = -1; 
#pragma data_seg()

// directive pour le link.

#pragma comment(linker, "/section:TestApp,rws") 

// Test incrémentation de la variable. 

bool bFirstInstance =  (InterlockedIncrement(&nCtApp) == 0);
if(!bFirstInstance)
{
       // erreur le prog est déjà lancé.
}

// .h
//
class CSdisamplesApp : public CWinApp
{
public:
CSdisamplesApp();
    ~CSdisamplesApp();
    CMutex     m_Mutex;
    bool       m_bLock;
    //................

// .cpp
CSdisamplesApp::CSdisamplesApp():m_bLock(false),m_Mutex(FALSE,"SDISAMPLE")
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
CSdisamplesApp::~CSdisamplesApp()
{
// Destruct
    if(m_bLock) m_Mutex.Unlock();    
}    
BOOL CSdisamplesApp::InitInstance()
{    
    if(!(m_bLock=m_Mutex.Lock(0)))
    {
        AfxMessageBox("Application active");
        return(0);
    }
//................

void RegisterShellFileTypes( BOOL bCompat = FALSE );

BOOL CMyApp::InitInstance() 
{ 
   // ... 

   CMultiDocTemplate* pDocTemplate; 
   pDocTemplate = new CMultiDocTemplate( 
      IDR_MYTYPE, 
      RUNTIME_CLASS(CMyDoc), 
      RUNTIME_CLASS(CMDIChildWnd),        // standard MDI child frame 
      RUNTIME_CLASS(CMyView)); 
   AddDocTemplate(pDocTemplate); 

   // Create main MDI Frame window. 
   CMainFrame* pMainFrame = new CMainFrame; 
   if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) 
      return FALSE; 
   // Save the pointer to the main frame window.  This is the 
   // only way the framework will have knowledge of what the 
   // main frame window is. 
   m_pMainWnd = pMainFrame; 

   // enable file manager drag/drop and DDE Execute open 
   EnableShellOpen(); 
   RegisterShellFileTypes(); 
   // ... 

   // Show the   main window using the nCmdShow parameter 
   // passed to the application when it was first launched. 
   pMainFrame->ShowWindow(m_nCmdShow); 
   pMainFrame->UpdateWindow(); 
  
   // ... 
}

 AfxGetApp()->m_lpCmdLine.

BOOL CSampleSDIApp::InitInstance()
{
    AfxEnableControlContainer();

    char szName[MAX_PATH];    
    GetModuleFileName(NULL,szName,MAX_PATH);

    CArray<CString ,const char *> argv; // attention il faut mettre #include <afxtempl.h> dans stdafx.h

    char *szArg=strtok(m_lpCmdLine," ");

    argv.Add(szName); // argv[0]=path de l'application.
    if(szArg) 
    {
        do
       {
          argv.Add(szArg);
       }
       while(szArg=strtok(NULL," "));
   }

    int argc=argv.GetSize();
    for(int i=0;i<argc;i++)
    {
        TRACE("\nArgv[%d]=%s",i,argv[i]);
    }
//..........................

CMyApp *pApp=static_cast<CMyApp *>(AfxGetApp());
pApp->m_Global.MyFunction();     //exemple de fonction globale 
CListCtrm &rList=pApp->m_Global.GetLisCtrl(); // variable globale.

namespace Singleton {

class MyClass
{
    private: static MyClass*  m_pUniqueInstance;
    private: static CMutex      m_LockInstance; // warning -> :#include <afxmt.h>

    private: MyClass(const MyClass&); // Disable copy constructor
    private: void operator=(const MyClass&); // Disable assignment operator

    private: MyClass()
    {
        // Initialisations
    }
    private: ~MyClass()
    { 
        m_pUniqueInstance = 0;
    }
    public: static MyClass &GetInstance()
    {
        if (m_pUniqueInstance == 0)
        {            
            m_LockInstance.Lock();
            if (m_pUniqueInstance == 0)
                m_pUniqueInstance = new MyClass();
            m_LockInstance.Unlock();
        }        
        return *m_pUniqueInstance;
    }
    public: static void FreeInstance()
    {
        m_LockInstance.Lock();
        delete m_pUniqueInstance;
        m_LockInstance.Unlock();
    }
    // users functions.    
    void UserFunction()
   {
        ASSERT(m_pUniqueInstance);
   }

};

}
// namespace Singleton
// init static data
CMutex     Singleton::MyClass::m_LockInstance;
Singleton::MyClass*  Singleton::MyClass::m_pUniqueInstance=NULL;

// utilisation.
Singleton::MyClass &theClass=Singleton::MyClass::GetInstance();
theClass.UserFunction();
// ou
Singleton::MyClass::GetInstance().UserFunction();
// libération
Singleton::MyClass::FreeInstance();

void CWinApp::LoadStdProfileSettings(UINT nMaxMRU)
{
    ASSERT_VALID(this);
    ASSERT(m_pRecentFileList == NULL);

    if (nMaxMRU != 0)
    {
        // create file MRU since nMaxMRU not zero
        m_pRecentFileList = new CRecentFileList(0, _afxFileSection, _afxFileEntry,
            nMaxMRU);
        m_pRecentFileList->ReadList();
    }
    // 0 by default means not set
    m_nNumPreviewPages = GetProfileInt(_afxPreviewSection, _afxPreviewEntry, 0);
}

class CMyApp : public CWinApp
{
public:
    CMyApp ();
    inline CRecentFileList *GetRecentFileList(){return m_pRecentFileList;}
//...
};

#include <afxadv.h>

void CTestToolBarView::OnInitialUpdate()
{
//...
  CMyApp *TheApp=static_cast<CMyApp *>(AfxGetApp());
    
    CString str;
    for( int i=0;TheApp->GetRecentFileList()->GetSize( );i++)
        str=(*TheApp->GetRecentFileList())[i];
}