ՄԻՈՒԹՅՈԻՆՆԵՐ

Միությունը - դա  գրառում է , որը ծրագրի կատարման ընթաց- քում օգտագործում է նրանում ընդգրկված տարրերից միայն մեկը:
Միությունների հայտարարման համար նախատեսված է union պահեստավորված բառը և օգտագործվում է նույն ընդհանուր գրելա-   ձևը, ինչպիսին գրառումների հայտարարման ժամանակ էր: Օրինակ`
                            union Type1
                            {
                             long  wt1;
                             int  wt2;
                             double  wt3;
                              };
                             Type1 w4;
                                            w4.wt3=4.83;

ԳՐԱՌՈՒՄՆԵՐԻ ԶԱՆԳՎԱԾՆԵՐ

Սահմանենք դասամատյանը որպես աշակերտների ցուցակª

const   int   MAX_STUDENTS  =  150:

             enum   tesakGnah   {A, B, C, D, E};

typedef  char  anvanatog[16]; //  կպարունակի 15 սիմվոլ և վերջում ‘\0’

struct   usanoxGnahatum

             {

              anvanatog    anun;

              anvanatog    azganun;

              int     thsragir;     //  գնահատականը ծրագրավորումից

              int     test;           //   գնահատականը թեստերից

              int     khnnuqun;     //   գնահատականը քննություններից

tesakGnah  gnahatakan;

};

//   փոփոխականների հայտարարում

usanoxGnahatum    gradeBook[MAX_STUDENTS];

int    length; 

int    c1;

Այս դեպքում երրորդ աշակերտի գնահատականը կտրվի հետևյալ ձևովª

gradeBook[2]. gnahatakan,

իսկ երրորդ աշակերտի ազգանվան առաջին տառը 

gradeBook[2]. anun[0]

գրելաձևով:

Հետևյալ հրահանգները արտածում են բոլոր աշակերտների անունները և ազգանուններըª

For  (c1 = 0; c1 < length;  c1++  )

             cout  <<  gradeBook[count]. anun  <<  ‘  ‘  

                      <<  gradeBook[c1]. azganun  <<  endl;

ԳՐԱՌՈՒՄՆԵՐ

Գրառումը - դա տարբեր  բնութագրեր ունեցող տվյալների համախումբ է: Գրառման տարրերին անվանում են  դաշտեր: Դաշտերին տրվում են որոշակի անուններ և այդ անունները օգտագործվում են  նրանց դիմելու համար: Գրառումը անվանում են նաև կառուցվածք,  իսկ  դաշտերը կառուցվածքի տարրեր: Գրառումների տրման համար C++ համակարգում նախատեսված է struct պահեստավորված բառը:
Գրառումների հայտարարման համար օգտագործվում է հե-   տևյալ ընդհանուր գրելաձևըª
  struct  Գրառման անուն
  {
  Դաշտերի ցուցակ
   };
Դաշտերին դիմելու համար  օգտագործվում է հետևյալ գրելաձևըª
 Գրառման անուն.Դաշտի անուն
Օրինակ, դիտարկենք գրառում, որը որոշակի տվյալներ է պարունակում դասարանի աշակերտների վերաբերյալ: Դրանք ենª  անունը, ազգանունը, ինչպես նաև ծրագրավորման, թեստերի, քննությունների և ընդհանուր  առաջադիմության գնահատականները:
       enum   tesakGnah   {A, B, C, D, E};
typedef  char  anvanatog[16];  //  կպարունակի 15 սիմվոլ և վերջում ‘\0’
      struct   usanoxGnahatum
         {
anvanatog     anun;
anvanatog     azganun;
int     thsragir;   //  գնահատականը ծրագրավորումից
int     test;         //   գնահատականը թեստերից
int     khnnuqun;  //   գնահատականը քննություններից
tesakGnah  gnahatakan;
                       };
     //   փոփոխականների հայտարարում
            usanoxGnahatum   student1;
                          usanoxGnahatum   student;
            int    index;
            int    lriv;
Օգտագործելով student  փոփոխականը ներքևում բերված ծրա-գիրը կարդում է բոլոր գնահատականները, գումարում է ծրագրավորու-մից, թեստերից և քննություններից ստացված գնահատականները: Կախված այդ արդյունքից յուրաքանչյուր աշակերտին վերագրում է տառային գնահատականներ և էկրանի վրա է արտածում ուսանողի ազ-գանունը, անունը, տառային գնահատականը:
cin  >>   student. thsragir >> student. test >> student. khnnuqun;
lriv  =   student. thsragir + student. test  + student. khnnuqun;
         if  (lriv  >=  900 )
student. gnahatakan = A;
else  if  (lriv  >=  800 )
student. gnahatakan = B;
else  if  (lriv  >=  700 )
student. gnahatakan = C;
                      else  if  (lriv  >=  600 )
student. gnahatakan = D;
                      else
student. gnahatakan = E;
                      cout<<student.anun <<student. azganun
                             << student. gnahatakan <<endl;
student  փոփոխականի հայտարարման ժամանակ նրան կարե-   լի է վերագրել նախնական արժեքներ, այն կատարվում է զանգվածների նման: Օրինակª
              usanoxGnahatum  student=
                {
    “Իվան”,
     “Գրիգորյան”,
     3.24,
                  320,
     290,
     95,
     B
                 };
Գրառման student.lastName տարրը զանգված է և նրա առանձին տարրերին պետք է դիմել ինչպես զանգվածի տարրի: Օրինակª
student. anun[0]- ով կարելի է դիմել ազգանվան առաջին տա-   ռին,  student. anun [1]- ով  երկրորդ տառին և այլն:
Եթե երկու գրառում ունեն միևնույն տիպը, ապա  նրանց նկատ-մամբ կարելի է կատարել վերագրման հրահանգը: Օրինակª
                  student1 = student;
Գրառումները ամբողջովին կարող են փոխանցվել ֆունկցիաներին  ինչպես ըստ արժեքների, այնպես էլ հղումով: Գրառումները ամբողջո-   վին կարող են վերադարձվել որպես ֆունկցիաների արժեքներ:

ԵՐԿՉԱՓԱՆԻ ԶԱՆԳՎԱԾՆԵՐ

Երկչափանի զանգվածների հայտարարման համար օգտագոր-ծում են հետևյալ ընդհանուր գրելաձևը`
        Տվյալի տեսակ  Զանգվածի անուն  [Ամբողջ թիվ1] [Ամբողջ թիվ2];
Ինչպես երևում է այդ գրելաձևից, երկչափանի զանգվածների հայտա-րարման ժամանակ ցույց են տրվում երկու չափ: Օրինակª
                  const  int  N1 = 52;
                  const  int  N2 = 7;
                           double a1 [ N1 ] [ N2 ];
a1 երկչափանի զանգվածը կունենա  52 տող և  7 սյուն:
Երկչափանի զանգվածի տարրերին սկզբնական արժեքներ կարելի է վերագրել հետևյալ գրելաձևի միջոցովª
                              int  age[2] [5] =
                             {
                   {23, 10, 16, 37, 12},
                               {3, 105, 1, 327, 15}
                              };
Ներքին ձևավոր փակագծերը, որոնց միջոցով ցուցակում ընդ-գրկված տվյալները բաժանվում են տողերի օգտագործվում են ծրա-   գիրը հեշտ ընթերնելի դարձնելու համար և նրանց  կարելի է չգրել: Այս-պես, վերևում բերված հրահանգը կարելի է  գրել նաև հետևյալ ձևովª
                                        int  age[2] [5] =
                          {23, 10, 16, 37, 12, 3, 105, 1, 327, 15 };

Խնդիր: Պահանջվում է գտնել 6-րդ կարգի քառակուսային մատ-րիցի  տարրերի մեծագույն արժեքը: Այդ խնդրի լուծումը իրագործում է հետևյալ ծրագիրը:
                                        #include <iostream.h>
                                        const  int  TOX = 6;
                                        int main()
                                        {
                                        long double  ak[TOX][TOX]=
                                        {{1.7,    0, -0.7, 0.05,    0, -0.35},
                                        {   0, 2.35,    0,   -2, -0.3,     0},
                                        {-0.7,    0,  2.7,    0,   -1,   0.35},
                                        {0.05,   -2,    0,  2.7,  0.3,  -0.35},
                                        {   0, -0.3,   -1,  0.3,    1,      0},
                                        {-0.35,   0, 0.35,-0.35,    0,  0.35}};
                                        long double  dmax;
                                        dmax=ak[0][0];
                                        int  i1,i2;
                                        for  (i1 = 0; i1  < TOX;  i1++)
                                        for  (i2 =0;  i2  < TOX;  i2++)
                                        {
                                        if (dmax <ak[i1][i2])            
                                        dmax=ak[i1][i2] ;
                                        }
                                        cout <<  dmax << endl;
                                        return 0;
                                        }

ՄԵԿ ՉԱՓԱՆԻ ԶԱՆԳՎԱԾՆԵՐ

Մեկ չափանի զանգվածը - մեկ ընդհանուր անունով միևնույն տեսակի տվյալների համախումբ է:
Մեկ չափանի զանգվածների հայտարարման   համար օգտագործում են հետևյալ ընդհանուր գրելաձևը`

ՏԻՊԵՐԻ ԲԱՑԱՀԱՅՏ ՁԵՎԱՓՈԽՈՒԹՅՈՒՆՆԵՐ

Տիպերի բացահայտ  ձևափոխություն կատարելու համար նա-խատեսված է  հետևյալ ընդհանուր գրելաձև ունեցող հրահանգը`
                         cast-name <  տիպ > ( արտ. );
Այստեղ  cast-name –ը  static_cast , const _cast ,  dynamic _cast     կամ  reinterpret_cast    առանցքային բառերից որևէ մեկն է, իսկ   տիպ –ը այն   տիպն է, որին բերվում է արտ.  արտահայտությունը:
static_cast առանցքային բառով իրագործվում են տիպերի  բոլոր այն ձևափոխությունները, որոնք կարող են կատարվել անբացահայտ ըստ լռելյայն սկզբունքի: Այդ տիպի ձևափոխությունից հետո կոմպիլյատորը տվյալի ճշտության կորուստի վերաբերյալ հաղորդագրութ-յուն  չի տալիս: Օրինակ`

ՏԻՊԵՐԻ ԱՆԲԱՑԱՀԱՅՏ ՁԵՎԱՓՈԽՈՒԹՅՈՒՆՆԵՐ

Ինչպես ասվեց վերևում, վերագրման գործողություններ կատա-րելու ժամանակ կոմպիլյատորը վերագրվող արժեքի տիպը անբացա-հայտորեն ձևափոխում է  օբյեկտի տիպի: Բացի այդ ձևափոխություննե-րից C++ համակարգը իր ներկառուցված օբյեկտների միջև սահմանում      է նաև ստանդարտ ձևափոխությունների համախումբ տարբեր տիպի օպերանդներ պարունակող թվաբանական արտահայտությունների հա-մար, տարբեր տիպեր ունեցող ֆունկցիայի փաստացի արգումենտի և համապատասխան ֆորմալ պարամետրի համար  և այլն:

ԱՐՏԱՀԱՅՏՈՒԹՅՈՒՆՆԵՐ

Արտահայտությունը, դա C++ համակարգի տարր կամ տարրերի համախումբ է, որի կատարման արդյունքում ստացվում է որոշակի տեսակի արժեք: Արտահայտությունները կազմված են օպերանդներից, գործողությունների նշաններից, բացող և փակող փակագծերից:
Արտահայտություններում որպես օպերանդներ կարող են հան-  դես գալ լիտերալներ, անվանումով հաստատուններ, փոփոխականներ, հղումներ, թվարկվող  տիպի տվյալներ, ֆունկցիաներ  և այլ  տիպի տվյալներ, որոնք  կուսումնասիրենք հետագայում:

ԳՈՐԾՈՂՈՒԹՅՈՒՆՆԵՐ

Այստեղ կդիտակենք  C++   համակարգում ներկառուցված  հա-ճախակի օգտագործվող հետևյալ տեսակի գործողությունները`
  -  թվաբանական
  -  համեմատման կամ բաղդատման
  -   տրամաբանական
  -   վերագրման
  -   ինկրեմենտ և դեկրեմենտ
  -   բիթային
  -   ձևափոխման գործողություններ
  -   sizeof  
  -  ստորակետ  
Թվաբանական գործողությունները հետևյալն են.
  +      մեկտեղանի գումարում
   -      մեկտեղանի  հանում
  +      երկտեղանի  գումարում
               -       երկտեղանի հանում
  *      բազմապատկում
  /       բաժանում
  %     ամբողջթվային բաժանման մնացորդ
Մեկտեղանի գործողությունը այն գործողությունն է, որը օգտա-գործում է մեկ օպերանդ: Երկտեղանի գործողությունը այն գործողութ-յունն է, որը օգտագործում է երկու օպերանդներ: Օրինակ`
                                               -2+5

ԱՐԺԵՔՆԵՐ ՎԵՐԱԴԱՐՁՆՈՂ ՖՈՒՆԿՑԻԱՆԵՐ

 C++  լեզվում   գոյություն ունեն արժեքներ վերադարձնող      երկու տեսակի ֆունկցիաներª -  ծրագրորդի կողմից ստեղծված և ներկառուցված ֆունկցիաներ:

Այս տիպի ֆունկցիաները կանչվում են  արտահայտություննե-   րից և վերադարձնում են միայն մեկ արժեք:

Ծրագրորդի կողմից ստեղծված ֆունկցիաները պարունակում են 

         return  Արտ. ;

հրահանգը, որի միջոցով  ֆունկցիան վերադարձնում է Արտ.  արտա-հայտության արժեքը: return հրահանգը void տիպի  ֆունկցիաներում  գրվում է  

return;

ՏԵՍԱՆԵԼԻՈՒԹՅԱՆ ՏԻՐՈՒՅԹ ԵՎ ԿՅԱՆՔԻ ՏԵՎՈՂՈՒԹՅՈՒՆ

Նույնարկողի տեսանելիության տիրույթը  - դա ելակետային ծրագրի այն ենթատեքստն է , որտեղ  տվյալ  նույնարկողը կարող է հանդես գալ միևնույն նշանակությամբ:
C++ լեզվում   ցանկացած նույնարկողի համար նախատեսված   են երեք կարգի տեսանելիության տիրույթներ`

ՖՈՒՆԿՑԻԱՆԵՐ, void ՏԻՊԻ ՖՈՒՆԿՑԻԱՆԵՐ

C++ լեզվում  նախատեսված են 2 տեսակի ֆունկցիաներ`

   1.Արժեքներ վերադաձնող ֆունկցիաներ - ֆունկցիաներ, որոնք կանչվում են  արտահայտություններից և վերադարձնում են միայն մեկ արժեք:
   2. void տեսակի ֆունկցիաներ(պրոցեդուրաներ) -  ֆունկցիաներ, որոնք կանչվում են առանձին հրահանգների միջոցով և  արժեքներ չեն վերա-դարձնում:


void  ՏԻՊԻ ՖՈՒՆԿՑԻԱՆԵՐ

void տիպի ֆունկցիան արտաքնապես շատ նման է  main() ֆունկցիային:  Միայն թե այստեղ նրա վերնագրի մեջ int առանցքային բառի փոխարեն գրվում է  void և քանի որ այն արժեքներ չի վերադարձնում կանչող ֆունկցիային, նա  չի պարունակում
                                           return 0;
տեսակի հրահանգ:

ԾՐԱԳՐԻ ԿԱՌՈՒՑՎԱԾՔԸ

C++ լեզվում ծրագիրը մեկ կամ մի քանի ֆունկցիաների համախումբ է: Ցանկացած ծագիր C++ լեզվում պետք է պարունակի ամբողջ թիվ վերադարձնող  main  անունով ֆունկցիան: Այդ ֆունկցիայից է սկսվում ծրագրի կատարումը:
 main() ֆունկցիայի առաջին տողը  գրվում է  հետևյալ  ձևով`
                    int    main()
C++ լեզվում  main() ֆունկցիայի նկատմամբ որպես կանչող ֆունկցիա  հանդես է գալիս օպերացիոն համակարգը: main() ֆունկցիան իր ավարտի ժամանակ օպերացիոն համակարգին է  վերադարձնում ամբողջ թվային արժեքներ, որոնցով ցույց է տրվում ծրագրի ավարտի վիճակը (exit status): Եթե  ծրագրի ավարտի վիճակը հավասար է 0, ապա  ըստ սահմանման համարվում է, որ ծրագիրը հաջող է ավարտվել, իսկ եթե ծրագրի ավարտի վիճակը այլ արժեքներ ունի (սո-վորաբար այն ունենում է 1,2,3 և այլ արժեքներ ) համարվում է, որ ծրա-գիրը անհաջող է ավարտվել: Ծրագրի ավարտի ժամանակ զերո արժեք վերադարձնելու համար main() ֆունկցիան պարունակում է
         return 0;
հրահանգը:

typedef ՀՐԱՀԱՆԳԸ

typedef  հրահանգը նախատեսված է տվյալների ներկառուց-   ված կամ կիրառական տիպերի հիման վրա սահմանել տվյալների տի-պերի հոմանիշեր: Այդ հրահանգը ունի հետևյալ ընդհանուր գրելաձևը`
typedef  Տվյալի տիպ  Հոմանիշի նույնարկող ;
Օրինակ, այս հրահանգի
              typedef  double du;
 կատարումից հետո  du  նույնարկողը կդառնա double տիպի հոմանիշ և d1, d2 փոփոխականների հայտարարման հետևյալ երկու հրահանգները  կլինեն համարժեք`                    
                                               double d1, d2 ;
                                               du  d1, d2 ;            
typedef  հրահանգով տվյալների տիպերի սահմանումը հնարա-վորություն է տալիս ծրագիրը դարձնել դյուրըմբռնելի: Այն հաճախակի օգտագործվում է բաղադրյալ և բարդ կառուցվածքով կազմովի տիպերի նշանակման համար:

bool ՏԻՊԻ ՏՎՅԱԼՆԵՐ

bool տեսակի օբյեկտը կարող է ունենալ true (իրական) և false (կեղծ) արժեքներից որևէ մեկը:
Չնայած, որ bool-ը ամբողջթվային տիպի է, սակայն այն չի    կարող հայտարարվել որպես  signed, unsigned, short  կամ long:
                                            short  bool  sb= false; // սխալ է
bool տեսակի օբյեկտները անբացահայտորեն ձևափոխվում են    int տիպի: true-ի արժեքը դառնում է 1, իսկ  false- ը`  0: Օրինակª
                               bool  fd = false;
                               int  iv = 0;
                               iv= iv+fd;
Նույն ձևով ամբողջ տիպի արժեքները և ցուցանշիչները կարելի     է ձևափոխել bool տեսակի: Ընդ որում, զերոն մեկնաբանվում է որպես false, իսկ զերոյից տարբերները որպես true:

ՀԱՍՑԵԻ ՏԻՊ ՈՒՆԵՑՈՂ ՏՎՅԱԼՆԵՐ

C++ միջավայրում ներկառուցված են  հասցեի տիպ ունեցող տըվ-յալներ, որոնք նախատեսված են տվյալներին հասցեներով հղում կատա-րելու համար: Դրանք են  ցուցանշիչային և հղումային տիպի տվյալները:
Ցուցանշիչը դա օբյեկտ է, որը պարունակում է այլ օբյեկտի  հասցե: Այն հնարավորություն է ընձեռում անուղղակի գործողություններ կատարել այդ  օբյեկտի հետ:
 Յուրաքանչյուր ցուցանշիչ զուգակցվում է որևէ տվյալի տիպի հետ: Ցուցանշիչներից  օգտվելու համար նրանք նախապես պետք է հայտարարել:  Հայտարարման  ժամանակ տրվում են ցուցանշիչին զուգակցվող փոփոխականի տիպը և ցուցանշիչի նույնարկողը: Ընդ  որում, ցուցանշիչի յուրաքանչյուր անունից առաջ  գրվում է աստղանիշ: Միևնույն հրահանգով կարելի է հայտարարել մեկ կամ մի քանի  ցուցանշիչներ: Օրինակներª
                              string   *p1;
                                           double    *dp;
                                           int   *ip1, *ip2;
 Ցուցանշիչի ցուցադրման աստղանիշը կարող է անջատ գրվել անունից և նույնիսկ այն կարող է անմիջապես հաջորդել տիպի տրման առանցքային բառին:  Հետևաբար, ներքևում բերված հրահանգները համարժեք են և ճիշտ:
                              string     * p1;
                              string*      p1;
Խորհուրդ է տրվում օգտագործել առաջին գրելաձևը:
Եթե միևնույն հրահանգով  հայտարարվել են մի քանի  ցուցանշիչներ, ապա  ցուցանշիչների բոլոր նույնարկողներից առաջ աստղանիշերը պերք է գրված լինեն: Այսպես, եթե գրված էª
                              string *pg, ps;
ապա նրանցից միայն առաջինը կլինի ցուցանշիչ:
Ցուցանշիչին չի կարելի վերագրել հասցե չհանդիսացող մեծություն, ինչպես նաև ցուցանշիչին չի կարելի վերագրել այլ տիպ  ունեցող օբյեկտի հասցե: Օրինակ, եթե կատարվել են հետևյալ հայտարարումները`
                               int   i1;
                                            double    d1;
                               int   *i2;
                                            double   *d2;
ապա ներքևում բերված վերագրման գործողությունները կլինեն սխալ
                                            i1=i2;
                                            d1=d2;
                                            i2=d2;
           Լինում են դեպքեր, երբ մեզ հետաքրքրում է հասցեի արժեքը, այլ  ոչ թե նրանով ցուցադրվող օբյեկտը (ենթադրենք ուզում ենք այդ     հասցեն համեմատել մեկ ուրիշ հասցեի հետ): Այդ դեպքերի համար նախատեսված է  void հատուկ տիպի ցուցանշիչը, որը կարող է   ցուցադրել ցանկացած տիպի տվյալ: Օրինակ, եթե  լրացուցիչ     կատարենք հետևյալ հայտարարումը`
                                           void  *ip;  
ապա վերագրման այս գործողությունները կլինեն ճիշտ `              
                                           ip =i2;
                                           ip =d2;
Ցուցանշիչին կարելի է գումարել կամ հանել ամբողջ արժեքներ: Ցուցանշիչին 1 ավելացնելը մեծացնում է նրա արժեքը համապատասխան տիպի օբյեկտի գրաված հիշողության չափով: Օրինակ, եթե double  տիպը գրավում է 8 բայթ հիշողություն, ապա եթե double  տիպի ցուցանշիչին ավելացնենք  3, նրա ցուցանշիչի արժեքը կմեծանա  24-ով:
Հղումային տիպը  ծառայում է օբյեկտին լրացուցիչ անուն տա-   լու համար:
Հղումային տիպը նշելու համար փոփոխականի անունից առաջ ցույց է տրվում հասցեի ցուցադրման գործողության նշանը (&): Հղումը անպայման պետք է ունենա  սկզբնական արժեքներ: Օրինակª
          int i1 = 1024;
          int  &i2 = i1;  // ճիշտ է, i2–ը հղում է i1-ին
          int  &i3;         // ճիշտ չէ, հղումը չունի  սկզբնական արժեք  
C++ ծրագրերում հղումները որպես ինքնուրույն օբյեկտներ քիչ են օգտագործում, սովորաբար նրանք   օգտագործում են որպես ֆունկցիաների ֆորմալ պարամետրեր:

Հաստատուններ

Բոլոր լիտերալների փոխարեն ծրագրում կարելի է օգտագոր-    ծել անվանումով հաստատուններ:
Անվանումով հաստատունը դա որոշակի անուն ունեցող հիշո-ղության տիրույթ է, որտեղ պահվում է հաստատուն  արժեքներ ունեցող տվյալներ:
Անվանումով հաստատունները հայտարարվում են const պահեստավորված բառով, ընդ որում նույնարկողի և լիտերալ արժեքի միջև դրվում է հավասարման ( =) նշան: Օրինակª
const  float   TAX_RATE=0.1254;
Անվանումով հաստատունների նույնարկողները խորհուրդ է տրվում գրել մեծատառերով, ինչը հնարավորություն է տալիս այն տար-բերել փոփոխականների նույնարկողներից:
Հաստատունի արժեքը ծրագրում փոփոխել հնարավոր չէ:
Ծրագրում կարելի է դիմել հաստատունին նրա անվան միջոցով:

ՓՈՓՈԽԱԿԱՆՆԵՐ

Փոփոխականը  կամ օբյեկտը դա որոշակի անուն ունեցող հիշողության տիրույթ է, որին ծրագրից կարելի է հղում կատարել: Փոփոխականներից օգտվելու համար նրանք նախապես պետք է հայտարարել: Հայտարարման  ժամանակ տրվում են փոփոխականի տիպը և նույնարկողը: Միևնույն հրահանգով կարելի է հայտարարել մեկ կամ մի քանի  փոփոխականներ: Օրինակներ`
int      i1;
fioat fa1;
int   ia1, ia2, ia3;
Խորհուրդ է տրվում  յուրաքանչյուր փոփոխականի համար նա-խատեսել առանձին արտահայտություն: Այդ դեպքում հեշտ է նոր փոփո-խական ավելացնել կամ հինը հեռացնել: Յուրաքանչյուր փոփոխականի համար  առանձին արտահայտության դեպքում նրանց հետ կարելի է գրել մեկնաբանություններ, որը ծրագիրը կդարձնի հեշտ ընթեռնելի: Օրինակª
         fioat  payRate;  // Ծառայողի աշխատավարձը
Փոփոխականների  հայտարարումը նրանց սկզբնական արժեք-ներ չի վերագրում: Եթե փոփոխականը (օբյեկտը) սահմանվում է որպես գլոբալ, ապա ըստ լռելյայն նրան վերագրվում է 0 արժեք: Եթե փոփոխականը (օբյեկտը) տեղական է կամ դինամիկ բնույթ ունի (սահմանվել է new հրահանգով), նրան սկզբնական արժեքներ չի վերագրվում: C++ լեզվում փոփոխականներին սկզբնական արժեքների վերագրման համար նախատեծված է երկու ձևª բացահայտ,      վերագրման հրահանգի օգտագործմամբ, օրինակª
        int i1 = 1024;
                      string s1 = “Fantasia 2001”;
և անբացահայտ, երբ սկզբնական արժեքները տրվում են փակագծերի մեջ`
                     int i1 (1024);
                     string s1 ( “Fantasia 2001”);
Փոփոխականների  ցուցակով հայտարարման ժամանակ     կարելի է օգտագործել  սկզբնական արժեքների տրման միայն բացա-հայտ եղանակը:
                     double d1 = 9999.99, d2 = d1+0.01;
                     int  month=08, day = 07 , year=2001;
Փոփոխականի  անունը կամ նույնարկողը կարող է բաղկացած լինել լատինական այբուբենի տառերից, թվանշաններից և ընդգծման գծից: C++ լեզվում նույնարկողի երկարությունը չի սահմանափակվում, բայց և այնպես շատ երկար անուններից օգտվելը բերում է անհարմա-րությունների: Որոշ բառեր  C++ լեզվում հանդիսանում են առանցքային բառեր և նրանց որպես նույնարկողներ օգտագործել չի կարելի: Այդ բառերի լրիվ ցուցակը բերված է թիվ 2 հավելվածում:
Որպեսզի ծրագրի տեքստը լինի ավելի հասկանալի խորհուրդ է տրվում  օգտագործել նույնարկողների գրելաձևի հետևյալ կանոններըª
1.Փոփոխականների նույնարկողները գրել փոքրատառերով:
2.Նույնարկողը պերք է ունենա որոշակի իմաստ: Օրինակª birth_date (ծննդյան թիվ):
3.Եթե անունը բաղկացած է մի քանի բառերից, ապա նրանք պետք է առանձնացնել ընդգծման գծով, կամ էլ, յուրաքանչյուր հաջորդ բառը սկսել մեծատառով: Օրինակª birthDate:
4.Փոփոխականների նույնարկողների համար օգտագործել §Հունգա-րական գրելաձև¦, որի ժամանակ օգտագործվում են որոշակի իմաստ արտահայտող հատուկ նախդիրներ: Հաճախակի օգտագործվող նախդիրների աղյուսյակը բերված է թիվ 4 հավելվածում: