C++ pamoka C vartotojams

Šis tekstas rodo ir pabrėžia savybės ir pagrindiniai principai C++. Jis skirtas patyrusiems C vartotojams, kurie nori išmokti C++. Jūs galėsite išreikšti savo kodą naudodamiesi turtingesnė C++ sintaksę ir jūs galėsite skaityti kai C++ kodą.

Nors sąvoka yra įdiegta ir padarė naudoti, tai ne pamoka apie Objektinis programavimas. Jūs vis dar turite išmokti OOP dvasią ir jos įgyvendinimo C++ detales, kad būtų tiesa, C++ programuotojas.

Jei jūs neturite C++ kompiliatorius po diseno de moda, gal pabandyti naudotis interneto priemones, pavyzdžiui, tai vienas: http://codepad.org

1. Naujas būdas įtraukti bibliotekas
   
   
2. // už vienos eilutės pastabas
   
   
3. Konsolės įvesties ir išvesties sistemos
   
   
4. Kintamos deklaracijas galima įdėti viduje kodas nenaudojant kabliukai
   
   
5. Kintamieji gali būti pradedamas skaičiavimu dalyvauja kiti kintamieji
   
   
6. Kintamieji gali būti paskelbta viduje for linijos deklaracijos
   
   
7. Globalių kintamųjų galima prieiti net vietinė kintamieji turi tą patį pavadinimą
   
   
8. Tai galima paskelbti NUORODĄ į kito kintamojo
   
   
9. Vardų galite būti pripažintas
   
   
10. Funkcija gali būti paskelbta inline
    
    
11. Išimtis struktūra buvo pridėta
    
    
12. Funkcija gali turėti numatytuosius parametrus
    
    
13. FUNKCIJA PERTEKLIŲ: Keletas funkcijų gali būti paskelbta su tuo pačiu pavadinimu jeigu yra skirtumas jų parametrų sąraše
    
    
14. Simboliniai operatoriai (+ - * / ...) gali būti apibrėžta už nauji duomenų tipai
    
    
15. Skirtingas funkcijas įvairių duomenų tipų automatiškai bus sukurtas, jei apibūdintumėte template funkciją
    
    
16. Raktažodžiai new ir delete daug geriau paskirstyti ir deallocate atminties
    
    
17. Jūs galite pridėti METODUS yra class ar struct
    
    
18. KONSTRUKTORIUS ir DESTRUKTORIUS gali būti naudojamas inicijuoti ir sunaikinti A klasės egzempliorius
    
    
19. Kompleksiniai klases reikia COPY KONSTRUKTORIUS ir perkrovos = operatoriaus
    
    
20. Šiuo metodu įstaigos gali būti apibrėžta toliau klasės apibrėžimą (ir Makefile naudojimo pavyzdžiui )
    
    
21. Raktinis žodis this yra rodyklė į Pavyzdžiui metodas, veikiantis ant
    
    
22. Matricos atvejais gali būti pripažintas
    
    
23. Kuris iš visiškai klasės deklaracijos pavyzdys
    
    
24. static kintamieji klasės apibrėžimas viduje
    
    
25. const kintamieji klasės apibrėžimas viduje
    
    
26. Klasė gali būti IŠSKIRTA iš kitos klasės
    
    
27. Jei metodas yra paskelbta virtual programa visada bus patikrinti pavyzdžiui, kad yra nurodomas ir bus panaudoti tinkamą metodą tipą.
    
    
28. Klasė gali būti gautas iš daugiau negu vienos pagrindinės klasės
    
    
29. Klasė išvedimas leidžia rašyti bendruosius metodus
    
    
30. KAPSULIAVIMAS: public, protected ir private
    
    
31. Trumpa pavyzdžiai I failų įvesties/išvesties
    
    
32. Simbolių masyvai gali būti naudojamas kaip failų
    
    
33. Kurio formato ir pavyzdys
    
    

1.

Yra naujas būdas #include bibliotekas (senas metodas vis dar veikia dar sudarytojas skundžiasi). .h plėtinys nėra naudojamas, bet daugiau, ir standartinės C bibliotekų pavadinimai rašomi pradedant nuo .c. Tam, kad programa naudoti šias bibliotekas teisingai using namespace std; turi būti pridėta:

using namespace std;
#include 
    // This is a key C++ library
#include cmath>
    // The standard C library math.h

int main ()
{
   double a;

   a = 1.2;
   a = sin (a);

   cout 
   return 0;
}

Keletas patarimų pradedantiesiems:

Sudaryti šią programą, įveskite jį (arba nukopijuokite & įklijuokite jį) į tekstinį redaktorių (gedit, Kwrite, Kate, kedit, VI, Emacs, nanotechnologijų, Piko, mcedit, Užrašų knygelė...), išsaugokite jį kaip failą, pavadintą, pasakyti test01.cpp (jei esate naujokas, geriausias įdėti šį failą viduje jūsų namų katalogą, kad yra, pavyzdžiui /home/jones Unix dėžutėje).

Kompiliuoti kodo failą, įveskite šią komandą (daugumoje atviro kodo Unix dėžės) A konsolės ar terminalo lange:

g++ test01.cpp -o test01

Norėdami paleisti dvejetainis vykdomąjį failą test01, kad buvo pagamintas rengimo (jei nebuvo klaidos), įveskite šį:

./test01

Kaskart keisti test01.cpp šaltinio kodo failą, jūs turite surinkti jį vėl, jei norite, kad pakeitimai būtų atsispindi test01 vykdomąjį failą (įrašykite rodyklės aukštyn klavišą klaviatūroje prisiminti komandas).

2.

Jūs galite naudoti // įvesti pastabą:

using namespace std;         // Using the standard library namespace.
#include           // The iostream library is often used.

int main ()                  // The program's main routine.
{
   double a;                 // Declaration of variable a.

   a = 456.47;
   a = a + a * 21.5 / 100;   // A calculation.

   cout // Display the content of a.

   return 0;                 // Program end.
}

(Galimybė naudoti // įvesti pastabas buvo įtraukta į C C99 ir ANSI C 2000)

3.

Įvesties iš klaviatūros ir išvesties į ekraną gali būti atliekamas per cout cin >>:

using namespace std;
#include 

int main()
{
   int a;                    // a is an integer variable
   char s [100];             // s points to a string of max 99 characters

   cout 

   cout // Just a line feed (end of line)

   cout    cin >> a;

   cout    cin >> s;

   cout 
   cout "Hello " s " you're " a " old." 
   cout 
   return 0;
}

4.

Kintamieji gali būti paskelbtas bet viduje kodas:

using namespace std;
#include 

int main ()
{
   double a;

   cout 
   cout    cin >> a;
                                                                                                 
   a = (a + 1) / 2;

   double c;

   c = a * 5 + 1;

   cout 
   int i, j;

   i = 0;
   j = i + 1;

   cout 
   return 0;
}

Gal pabandyti naudoti šią funkciją, kad jūsų kodo suprantamesnės, o ne netvarka jį.

Kaip ir C, kintamieji gali būti atitverti tarp { } blokus. Tada jie yra vietinio taikymo sritį į zoną aplieti tarp { ir }. Kad ir kas nutiktų su tokių kintamųjų viduje aplieti zonoje neturės įtakos zonai nepriklausančias:

using namespace std;
#include 

int main ()
{
   double a;

   cout    cin >> a;

   {
      int a = 1;
      a = a * 10 + 4;
      cout 
   }

   cout 
   return 0;
}

5.

Kintamasis gali būti pradedamas skaičiavimu dalyvavo kitus kintamuosius:

using namespace std;
#include 

int main ()
{
   double a = 12 * 3.25;
   double b = a + 1.112;

   cout    cout 
   a = a * 2 + b;

   double c = a + b * a;

   cout 
   return 0;
}

6.

C++ leidžia paskelbti kintamąjį būtų vietos į kilpą:

using namespace std;
#include 

int main ()
{   
   int i;                       // Simple declaration of i
   i = 487;

   for (int i = 0; i // Local declaration of i 
   {
      cout // This outputs 0, 1, 2 and 3
   }

   cout // This outputs 487

   return 0;
}

Jei kintamasis yra nedeklaravo kažkur virš kilpos, jums gali būti linkusios jį naudoti toliau kilpą. Kai kurie ankstyvi C++ kompiliatorius tai priimti. Tada kintamasis turi reikšmę tai turėjo kai kilpa baigėsi. Jūs ne tai turėtų daryti. Tai laikoma bloga praktika:

using namespace std;
#include 

int main ()
{

   for (int i = 0; i    {
      cout    }

   cout            // Bad practice!
   i += 5;                      // Bad practice!
   cout            // Bad practice!

   return 0;
}

7.

Pasaulinė kintamasis gali būti atvertas net jei kitas kintamasis tuo pačiu pavadinimu buvo paskelbtas viduje funkcijos:

using namespace std;
#include 

double a = 128;

int main ()
{
   double a = 256;

   cout    cout ::a 
   return 0;
}

8.

Ji yra įmanoma, kad vienas kintamasis būti dar vienas:

using namespace std;
#include 

int main ()
{
   double a = 3.1415927;

   double &b = a;                            // b is a

   b = 89;

   cout // Displays 89.

   return 0;
}

(Jei yra naudojamos rodyklės ir absoliučiai nori žinoti, kas atsitiks, tiesiog manau, kad double &b = a yra išverstas double *b = &a ir visus vėlesnius b pakeičiami *b.)

ETALONINIŲ b vertė negali būti pakeistas po jo deklaracijoje. Pavyzdžiui Jūs negalite rašyti, keletą eilučių toliau, &b = c tikintis, kad b yra dabar c. Jis negali dirbti. Viskas yra sakoma deklaracijoje eilutėje b. Nuoroda b ir kintamojo a yra susituokę ant tos linijos ir nieko juos atskirti.

Nuorodos gali būti naudojamas, kad būtų galima funkcija pakeisti skambinimo kintamąjį:

using namespace std;
#include 

void change (double &r, double s)
{
   r = 100;
   s = 200;
}

int main ()
{
   double k, m;

   k = 3;
   m = 4;

   change (k, m);

   cout // Displays 100, 4.

   return 0;
}

Jei yra naudojamos rodyklės C ir įdomu, kaip tiksliai virš darbų programa, čia yra kaip C++ kompiliatorius būtų išversti į C:

using namespace std;
#include 

void change (double *r, double s)
{
   *r = 100;
   s = 200;
}

int main ()
{
   double k, m;

   k = 3;
   m = 4;

   change (&k, m);

   cout // Displays 100, 4.

   return 0;
}

Nuoroda gali būti naudojama tegul funkcija grąžina kintamąjį:

using namespace std;
#include 

double &biggest (double &r, double &s)
{
   if (r > s) return r;
   else       return s;
}

int main ()
{
   double k = 3;
   double m = 7;

   cout // Displays  3
   cout // Displays  7
   cout 
   biggest (k, m) = 10;

   cout // Displays  3
   cout // Displays 10
   cout 
   biggest (k, m) ++;

   cout // Displays  3
   cout // Displays 11
   cout 
   return 0;
}

Vėlgi, jei esate pripratę prie žymeklį aritmetiką ir jei jums įdomu, kaip aukščiau darbų programa, tiesiog įsivaizduokite, kad kompiliatorius išversti jį į šią standartinę C programą:

using namespace std;
#include 

double *biggest (double *r, double *s)
{
   if (*r > *s) return r;
   else         return s;
}

int main ()
{
   double k = 3;
   double m = 7;

   cout    cout    cout 
   (*(biggest (&k, &m))) = 10;

   cout    cout    cout 
   (*(biggest (&k, &m))) ++;

   cout    cout    cout 
   return 0;
}

Norėdami baigti su, žmonėms, kurie turi susidoroti su rodyklėmis dar nepatinka, nuorodos Naudingos veiksmingai JT rodyklė kintamieji. Saugokitės tai galima laikyti bloga praktika, ir gali jums į bėdą. Žr http://web.archive.org/web/20131011080757/http://www.embedded.com/electronics-blogs/programming-pointers/4023307/References-vs-Pointers

using namespace std;
#include 

double *silly_function ()    // This function returns a pointer to a double
{
   static double r = 342;
   return &r;
}

int main ()
{
   double *a;

   a = silly_function();

   double &b = *a;          // Now b is the double towards which a points!

   b += 1;                  // Great!
   b = b * b;               // No need to write *a everywhere!
   b += 4;

   cout 
   return 0;
}

9.

Vardų galima deklaruoti. Nurodytos per vardų kintamieji gali būti naudojamas dėka :: operatorius:

using namespace std;
#include 
#include 

namespace first
{
   int a;
   int b;
}

namespace second
{
   double a;
   double b;
}

int main ()
{
   first::a = 2;
   first::b = 5;

   second::a = 6.453;
   second::b = 4.1e4;

   cout    cout 
   return 0;
}

10.

Jei funkcija yra tik paprastas eilutes kodo, nenaudoja for kilpomis ar panašiai, jis gali būti pripažintas Inline. Tai reiškia, jo kodas bus įterptas visur funkcija naudojama. Štai šiek tiek panašus į makro. Pagrindinis privalumas yra tai, programa bus greičiau. Mažas trūkumas yra tai, ji bus didesnis, nes buvo įterptas jai visur taikyti visą kodas funkcijos:

using namespace std;
#include 
#include 

inline double hypothenuse (double a, double b)
{
   return sqrt (a * a + b * b);
}

int main ()
{
   double k = 6, m = 9;

   // Next two lines produce exactly the same code:

   cout hypothenuse (k, m)    cout 
   return 0;
}

(Inline funkcijos buvo įtraukta į C C99 ir ANSI C 2000)

11.

Jūs žinote, klasikines kontrolės struktūras C: for, if, do, while, switch... C++ prideda dar viena valdymo struktūra, pavadintą EXCEPTION:

using namespace std;
#include 
#include 

int main ()
{
   int a, b;

   cout    cin >> a;
   cout 
   try
   {
      if (a > 100) throw 100;
      if (a 
      throw a / 3;
   }
   catch (int result)
   {
      cout 
      b = result + 1;
   }

   cout 
   cout 
   // another example of exception use:

   char zero []     = "zero";
   char pair []     = "pair";
   char notprime [] = "not prime";
   char prime []    = "prime";

   try
   {
      if (a == 0) throw zero;
      if ((a / 2) * 2 == a) throw pair;
      for (int i = 3; i 
      {
         if ((a / i) * i == a) throw notprime;
      }
      throw prime;
   }
   catch (char *conclusion)
   {
      cout 
   }

   cout 
   return 0;
}

12.

Ji yra įmanoma, kad nustatyti numatytuosius parametrus funkcijų:

using namespace std;
#include 

double test (double a, double b = 7)
{
   return a - b;
}

int main ()
{
   cout // Displays 14 - 5
   cout // Displays 14 - 7

   return 0;
}

13.

Vienas svarbus privalumas C++ yra FUNKCIJA PERKROVOS. Skirtingas funkcijas gali turėti tokį patį vardą, jei kažkas leidžia kompiliatorius juos atskirti: parametrų skaičiaus, tipo parametrų...

using namespace std;
#include 

double test (double a, double b)
{
   return a + b;
}

int test (int a, int b)
{
   return a - b;
}

int main ()
{
   double   m = 7,  n = 4;
   int      k = 5,  p = 3;

   cout 
   return 0;
}

14.

OPERATORIAUS PERKROVA gali būti naudojamas iš naujo apibrėžti pagrindinius simbolines operatorių naujų rūšių parametrų:

using namespace std;
#include 

struct vector
{
   double x;
   double y;
};

vector operator * (double a, vector b)
{
   vector r;

   r.x = a * b.x;
   r.y = a * b.y;

   return r;
}

int main ()
{
   vector k, m;              // No need to type "struct vector"

   k.x =  2;                 // To be able to write
   k.y = -1;                 // k = vector (2, -1)
                             // see chapter 19.

   m = 3.1415927 * k;        // Magic!

   cout 
   return 0;
}

Be to daugyba, 43 kitų pagrindinių C++ operatoriai gali būti perkrautas, įskaitant + =, ++ masyvo [], ir tt...

cout ). Tai galima dar apkrauti

using namespace std;
#include 

struct vector
{
   double x;
   double y;
};

ostream& operator 
{
   o 
   return o;
}

int main ()
{
   vector a;

   a.x = 35;
   a.y = 23;

   cout  // Displays (35, 23)

   return 0;
}

15.

Pavargę apibrėžti tą pačią funkciją penkis kartus? Vienas apibrėžimas int tipo parametrų, vienas apibrėžimas double tipo parametrų, vienas apibrėžimas float tipo parametrų... Argi tu pamiršai vieną tipą? Ką daryti, jei nauja duomenų tipas naudojamas? Jokių problemų: C++ kompiliatorius gali automatiškai generuoti kiekvieną funkciją, kuri yra būtina versija! Tiesiog pasakyti, kaip ši funkcija atrodo deklaruojant template funkciją:

using namespace std;
#include 

template 
ttype minimum (ttype a, ttype b)
{
   ttype r;

   r = a;
   if (b 

   return r;
}

int main ()
{
   int i1, i2, i3;
   i1 = 34;
   i2 = 6;
   i3 = minimum (i1, i2);
   cout 
   double d1, d2, d3;
   d1 = 7.9;
   d2 = 32.1;
   d3 = minimum (d1, d2);
   cout 
   cout minimum (d3, 3.5) 
   return 0;
}

Ši funkcija minimalus naudojamas tris kartus aukščiau programą, tačiau C++ kompiliatorius generuoja tik dvi versijos IT: int minimum (int a, int b) ir double minimum (double a, double b). Tai daro už visos programos darbą.

Kas nutiktų, jei bandėte kažką panašaus apskaičiuojant minimum (i1, d1)? Kompiliatorius būtų pranešė, kad įvyko klaida. Tai todėl, kad šablonas teigiama, kad abu parametrai yra to paties tipo.

Jūs galite naudoti bet kokiam skirtingų šablonų duomenų tipų šabloną apibrėžimą. Ir ne visi parametrų tipai turi būti šablonai, kai kurie iš jų gali būti standartinių tipų ar vartotojo nustatytas (char, int, double...). Čia yra pavyzdys, kai minimum funkcija priima parametrus bet kokio tipo (skirtingų arba tas pats) ir išveda vertę, kuri turi pirmojo parametro tipas:

using namespace std;
#include 

template 
type1 minimum (type1 a, type2 b)
{
   type1 r, b_converted;
   r = a;
   b_converted = (type1) b;
   if (b_converted    return r;
}

int main ()
{
   int i;
   double d;

   i = 45;
   d = 7.41;

   cout    cout    cout 
   return 0;
}

(ASCII kodas charakterio "-" yra 45, o "A" kodas yra 65.)

16.

Raktažodžiai new ir delete gali būti naudojamas paskirstyti ir deallocate atmintis. Jie yra švaresnis nei funkcijas malloc ir be standartinio C

new [] ir delete [] yra naudojamas matricos.

using namespace std;
#include 
#include 

int main ()
{
   double *d;                         // d is a variable whose purpose
                                      // is to contain the address of a
                                      // zone where a double is located


   d = new double;                    // new allocates a zone of memory
                                      // large enough to contain a double
                                      // and returns its address.
                                      // That address is stored in d.

   *d = 45.3;                         // The number 45.3 is stored
                                      // inside the memory zone
                                      // whose address is given by d.

   cout    cin >> *d;

   *d = *d + 5;

   cout 
   delete d;                          // delete deallocates the
                                      // zone of memory whose address
                                      // is given by pointer d.
                                      // Now we can no more use that zone.


   d = new double[15];                // allocates a zone for an array
                                      // of 15 doubles. Note each 15
                                      // double will be constructed.
                                      // This is pointless here but it
                                      // is vital when using a data type
                                      // that needs its constructor be
                                      // used for each instance.

   d[0] = 4456;
   d[1] = d[0] + 567;

   cout 
   delete [] d;                       // delete [] will deallocate the
                                      // memory zone. Note each 15
                                      // double will be destructed.
                                      // This is pointless here but it
                                      // is vital when using a data type
                                      // that needs its destructor be
                                      // used for each instance (the ~
                                      // method). Using delete without
                                      // the [] would deallocate the
                                      // memory zone without destructing
                                      // each of the 15 instances. That
                                      // would cause memory leakage.

   int n = 30;

   d = new double[n];                 // new can be used to allocate an
                                      // array of random size.
   for (int i = 0; i    {
      d[i] = i;
   }

   delete [] d;


   char *s;

   s = new char[100];

   strcpy (s, "Hello!");

   cout 
   delete [] s;

   return 0;
}

17.

Be standartinio C, struct yra tik duomenis. C++ A struct apibrėžimas taip pat gali būti nustatytas funkcijas. Tos funkcijos priklauso struct ir yra skirti veikti ant struct duomenis. Tos funkcijos yra vadinamos metodais. Pavyzdys žemiau apibrėžia metodo surface() dėl struct vector:

using namespace std;
#include 

struct vector
{
   double x;
   double y;

   double surface ()
   {
      double s;
      s = x * y;
      if (s 
      return s;
   }
};

int main ()
{
   vector a;

   a.x = 3;
   a.y = 4;

   cout a.surface() 
   return 0;
}

Aukščiau pavyzdžiui, a yra iš struct "vektorius" ATVEJIS. (Atkreipkite dėmesį, kad raktažodis "struct", deklaruojant vektorių a nebuvo būtina.)

Tiesiog kaip funkcija, metodas gali būti bet kokio C++ operatorius perkrovos, jokių parametrų skaičių (dar vienas parametras yra visada numanoma: egzempliorius jis veikia ant), grąžinti bet kokio parametro tipą, arba grąžinti ne parametrą ne visiems.

Kas yra class? Tai struct, kad išlaiko savo duomenis paslėptas. Tik gali prieiti prie duomenų, kad šios class metodus. Jūs negalite tiesiogiai prieiti prie duomenų, išskyrus atvejus, kai leidžiama pagal public: direktyva. Čia yra class apibrėžimo pavyzdys. Jis elgiasi lygiai taip pat, kaip aukščiau struct pavyzdžiui, nes klasės duomenis x ir y yra apibrėžiamas kaip visuomenės:

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;

   double surface ()
   {
      double s;
      s = x * y;
      if (s       return s;
   }
};

int main ()
{
   vector a;

   a.x = 3;
   a.y = 4;

   cout 
   return 0;
}

Aukščiau pateiktame pavyzdyje, main() funkcija keičia Pavyzdžiui duomenis a tiesiogiai, naudojant a.x = 3, a.y = 4. Tai tapo įmanoma public: direktyvą klasės apibrėžimą. Manoma, kad tai bloga praktika. Žiūrėkite 30 skyrių.

Metodas yra leidžiama pakeisti į atveju tai yra, veikiančią kintamuosius:

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;

   vector its_opposite()
   {
      vector r;

      r.x = -x;
      r.y = -y;

      return r;
   }

   void be_opposited()
   {
      x = -x;
      y = -y;
   }

   void be_calculated (double a, double b, double c, double d)
   {
      x = a - c;
      y = b - d;
   }

   vector operator * (double a)
   {
      vector r;

      r.x = x * a;
      r.y = y * a;

      return r;
   }
};

int main ()
{
   vector a, b;

   a.x = 3;
   a.y = 5;

   b = a.its_opposite();

   cout    cout 
   b.be_opposited();
   cout 
   a.be_calculated (7, 8, 3, 2);
   cout 
   a = b * 2;
   cout 
   a = b.its_opposite() * 2;
   cout 
   cout 
   return 0;
}

18.

Labai ypatinga ir eteriniai metodai yra KONSTRUKTORIUS ir DESTRUKTORIUS. Jie automatiškai vadinama, kai tik A klasės egzempliorius yra sukurta ar sunaikinta (kintamasis deklaracija, pabaigos programą, new, delete...).

Konstruktorius bus inicijuoti į Pavyzdžiui kintamuosius, atlikti tam tikrus skaičiavimus, skirti už instancijos wypisuje teksto ... kokia reikalinga tam atmintį.

Čia yra klasės apibrėžimą su dviem perpildytą konstruktorių pavyzdys:

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;

   vector ()                     // same name as class
   {
      x = 0;
      y = 0;
   }

   vector (double a, double b)
   {
      x = a;
      y = b;
   }

};

int main ()
{
   vector k;                     // vector () is called

   cout 
   vector m (45, 2);             // vector (double, double) is called

   cout 
   k = vector (23, 2);           // vector created, copied to k, then erased

   cout 
   return 0;
}

Tai gera praktika pabandyti neperkrauti konstruktoriai. Tai geriausia deklaruoti tik vienas konstruktorius ir mano, kad tai gamyklinių parametrų, kur tik įmanoma:

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }
};

int main ()
{
   vector k;
   cout 
   vector m (45, 2);
   cout 
   vector p (3);
   cout 
   return 0;
}

Destructor dažnai yra nereikalinga. Jūs galite naudoti ją padaryti kai skaičiavimus, kai egzempliorius sunaikinti arba išvesties kai tekstą derinti... Bet jei kintamieji pavyzdžiui punkto kai paskirta atminties tada destructor vaidmuo yra esminis: jis turi atlaisvinti tą atmintį! Čia yra tokios paraiškos pavyzdys:

using namespace std;
#include 
#include 

class person
{
public:

   char *name;
   int age;

   person (char *n = "no name", int a = 0)
   {
      name = new char [100];                 // better than malloc!
      strcpy (name, n);
      age = a;
      cout    }

   ~person ()                               // The destructor
   {
      delete name;                          // instead of free!

                                            // delete [] name would be more
                                            // academic but it is not vital
                                            // here since the array contains
                                            // no C++ sub-objects that need
                                            // to be deleted.

      cout    }
};

int main ()
{
    cout 
    person a;
    cout 
    person b ("John");
    cout 
    b.age = 21;
    cout 
    person c ("Miki", 45);
    cout 
    cout 
   return 0;
}

Čia yra trumpas pavyzdys masyvo klasės apibrėžimą. Metodas, kuris yra iš [] operatoriaus perkrovos ir išėjimai nuorodą (&) yra naudojamas tam, kad generuoti klaidos, jei mėginama prieiti prie duomenų už masyvo ribų:

using namespace std;
#include 
#include 

class array
{
public:
   int size;
   double *data;

   array (int s)
   {
      size = s;
      data = new double [s];
   }

   ~array ()
   {
      delete [] data;
   }

   double &operator [] (int i)
   {
      if (i = size)
      {
         cerr 
         exit (EXIT_FAILURE);
      }
      else return data [i];
   }
};

int main ()
{
   array t (5);

   t[0] = 45;                       // OK
   t[4] = t[0] + 6;                 // OK
   cout t[4] // OK

   t[10] = 7;                       // error!

   return 0;
}

19.

Jei jums mesti objektą kaip vektorius, viskas įvyks teisingai. Pavyzdžiui, jei vektorius k kurio sudėtyje yra (4, 7), po to, kai lieto m = k vektorius m, yra (4, 7) taip pat Į k.x ir k.y vertybės tiesiog buvo nukopijuotas į m.x ir m.y. Dabar tarkime, kad žaidi su objektais, pavyzdžiui, person klasės aukščiau. Šie objektai yra rodyklė į simbolių eilutę. Jei jums mesti person objektą raštu p = r yra susigrąžintos, kad kai funkcija daro šį darbą padaryti p būti teisinga kopija r. Priešingu atveju, p.name nukreips į tą patį fizinį simbolių eilutę kaip r.name. Dar daugiau, buvusi simbolių atkreipė dėmesį į iki p.name yra prarasta ir tampa atminties Zombie. Rezultatas bus katastrofiška: iš rodyklės ir prarastų duomenų netvarka. Metodai, kurie bus atlikti darbą yra KOPIJA KONSTRUKTORIUI ir kad, = operatoriaus perkrovos:

using namespace std;
#include 
#include 

class person
{
public:

   char *name;
   int age;

   person (char *n = "no name", int a = 0)
   {
      name = new char[100];
      strcpy (name, n);
      age = a;
   }

   person (const person &s)      // The COPY CONSTRUCTOR
   {
      name = new char[100];
      strcpy (name, s.name);
      age = s.age;
   }

   person& operator= (const person &s)  // overload of =
   {
      strcpy (name, s.name);
      age = s.age;
      return *this;
   }

   ~person ()
   {
      delete [] name;
   }
};

void modify_person (person& h)
{
   h.age += 7;
}

person compute_person (person h)
{
   h.age += 7;
   return h;
}


int main ()
{
   person p;
   cout    // output: no name, age 0

   person k ("John", 56);
   cout    // output: John, age 56

   p = k;
   cout    // output: John, age 56

   p = person ("Bob", 10);
   cout    // output: Bob, age 10

   // Neither the copy constructor nor the overload
   // of = are needed for this operation that modifies 
   // p since just the reference towards p is passed to
   // the function modify_person:  
   modify_person (p);
   cout    // output: Bob, age 17

   // The copy constructor is called to pass a complete 
   // copy of p to the function compute_person. The 
   // function uses that copy to make its computations
   // then a copy of that modified copy is made to 
   // return the result. Finally the overload of = is 
   // called to paste that second copy inside k:
   k = compute_person (p);
   cout    // output: Bob, age 17
   cout    // output: Bob, age 24

   return 0;
}

Kopija konstruktorius leidžia savo programą kopijuoti atvejais, kai daro skaičiavimus. Ji yra pagrindinis metodas. Per skaičiavimais, atvejų yra sukurta, siekiant išlaikyti tarpinius rezultatus. Jie keisti, mesti ir sunaikinti be jūsų žinios. Tai kodėl šie metodai gali būti naudinga net paprastų objektų (žr 14 skyrių).

Be visų minėtų pavyzdžių, metodai yra apibrėžti klasės apibrėžimas viduje. Tai automatiškai daro juos Inline metodus.

20.

Jei metodas negali būti Inline arba nenorite, kad jis būtų Inline arba jei norite, kad klasės apibrėžimas yra minimalų kiekį informacijos (arba jūs tiesiog norite įprastą atskirą .h antraštės failą ir .cpp kodo failą) , tada jums reikia įdėti tik iš klasės viduje metodo prototipą ir apibrėžti žemiau klasės metodą (arba atskiroje .cpp šaltinio failo):

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;

   double surface();         // The ; and no {} show it is a prototype
};

double vector::surface()
{
   double s = 0;

   for (double i = 0; i    {
      s = s + y;
   }

   return s;
}

int main ()
{
   vector k;

   k.x = 4;
   k.y = 5;

   cout 
   return 0;
}

Pradedantiesiems:

Jei ketinate kurti rimtą C ar C++ programą, jums reikia atskirti kodą į .h header files ir .cpp šaltinio failus. Tai yra trumpas pavyzdys, kaip tai daroma. Programa aukščiau yra padalyta į tris failus:

Antraštės failą vector.h:

class vector
{
public:

   double x;
   double y;

   double surface();
};

Šaltinis failą vector.cpp:

using namespace std;
#include "vector.h"

double vector::surface()
{
   double s = 0;

   for (double i = 0; i    {
      s = s + y;
   }

   return s;
}

Ir dar vienas šaltinio failas main.cpp:

using namespace std;
#include 
#include "vector.h"

int main ()
{
   vector k;

   k.x = 4;
   k.y = 5;

   cout 
   return 0;
}

Darant prielaidą, kad vector.cpp yra tobulas, jums surinkti jį vieną kartą ir visiems laikams į .o "objektas failo". Toliau pateiktoje komanda gamina, kad objekto kodo failą, pavadintą vector.o:

g++ -c vector.cpp

Kaskart keisti main.cpp šaltinio failą, kaupia jį į vykdomąjį failą, tarkim test20. Jūs pasakykite kompiliatorius aiškiai nurodoma, kad jis turi susieti vector.o objekto failą į galutinį test20 vykdomąjį:

g++ main.cpp vector.o -o test20

Paleiskite vykdomąjį šį kelią:

./test20

Tai turi keletą privalumų:

• Išeities kodas vector.cpp nereikia būti rengiami tik vieną kartą. Tai taupo laiką dėl didelių projektų daug. (Susiejimas vector.o failą į test20 vykdomąjį yra labai greitas.)
• Galite somebody give .h failą ir .o failą(-s). Tokiu būdu jie gali naudoti savo programinę įrangą, bet ne jį pakeisti, nes jie neturi .cpp failą (-us) (nepasikliaukite per daug apie tai, palaukite kol meistras į šiuos klausimus).

Pastaba Jums gali sudaryti main.cpp per į objekto failą ir tada susieti jį su vector.o:

g++ -c main.cpp
g++ main.o vector.o test20

Tai nuklysta nuo "skirtumus tarp C ir C++" temą, bet jei norite atrodyti realus programuotojas, jums reikia kondensuoti pirmiau komandas į Makefile ir kaupia naudojant makiažo komandą. Failas turinys po yra pernelyg supaprastintu versija tokio Makefile. Nukopijuokite jį į failą pavadintą Makefile. Atkreipkite dėmesį, o tai yra labai svarbu, kad prieš g++ vadovaujamai erdvė yra privalomas ir kad tai yra "Tab" personažas. Negalima įveskite tarpo čia. Vietoj naudoti lentelių sudarymo raktą (visą kairę jūsų klaviatūros, virš didžiosios raidės).

test20: main.o vector.o
	g++ main.o vector.o -o test20

main.o: main.cpp vector.h
	g++ -c main.cpp

vector.o: vector.cpp vector.h
	g++ -c vector.cpp

Kad naudoti kad Makefile kaupti, tipas:

make test20

Markę komanda bus apdoroti per failų Makefile ir išsiaiškinti, ką jis turi daryti. Norėdami pradėti su, tai sakė, kad test20 priklauso nuo main.o ir vector.o. Taigi bus automatiškai paleisti "make main.o", bei "make vector.o ". Tada jis patikrins, ar test20 jau egzistuoja ir tikrina datos antspaudai su test20, main.o ir  vector.o. Jei test20 jau egzistuoja ir main.o ir vector.o turėti data antspaudas anksčiau nei test20, make komanda nustato, kad dabartinė versija test20 yra atnaujinami, todėl neturi nieko. Jis tiesiog apie tai pranešti nieko. Priešingu atveju, jei neegzistuoja test20 arba main.o arba  vector.o yra naujesnis negu test20, komanda, kuri sukuria up-to-data versiją test20 atliekamas: g++ main.o vector.o -o test20.

Tai naujos versija Makefile yra arčiau į standartinį Makefile:

all: test20

test20: main.o vector.o
	g++ main.o vector.o -o test20

main.o: main.cpp vector.h
	g++ -c main.cpp

vector.o: vector.cpp vector.h
	g++ -c vector.cpp

clean:
	rm -f *.o test20 *~ #*

Jūs sukelti rengimo tiesiog įvesdami make komandą. Pirmoje eilutėje Makefile reiškia, kad jei jūs tiesiog įveskite make  jums skirtas "make test20":

make

Ši komanda ištrina visus failus gaminami rengimo metu ir visus teksto redaktorius atsarginių kopijų failus:

make clean

21.

Kai metodas yra taikoma bet kad, pavyzdžiui, metodas gali naudoti Pavyzdžiu kintamuosius, juos pakeisti... Bet kartais tai yra būtina žinoti Pavyzdžiui adresą. Ne problema, raktinis žodis tai yra skirti tam tikslui:

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   double module()
   {
      return sqrt (x * x + y * y);
   }

   void set_length (double a = 1)
   {
      double length;

      length = this->module();

      x = x / length * a;
      y = y / length * a;
   }
};

int main ()
{
   vector c (3, 5);

   cout 
   c.set_length(2);            // Transforms c in a vector of size 2.

   cout 
   c.set_length();             // Transforms b in an unitary vector.

   cout 
   return 0;
}

22.

Žinoma, ji yra įmanoma pripažinti matricos objektų:

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   double module ()
   {
      return sqrt (x * x + y * y);
   }
};

int main ()
{
   vector s [1000];

   vector t[3] = {vector(4, 5), vector(5, 5), vector(2, 4)};

   s[23] = t[2];

   cout 
   return 0;
}

23.

Čia yra pilna klasės deklaracijos pavyzdys:

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double = 0, double = 0);

   vector operator + (vector);
   vector operator - (vector);
   vector operator - ();
   vector operator * (double a);
   double module();
   void set_length (double = 1);
};

vector::vector (double a, double b)
{
   x = a;
   y = b;
}

vector vector::operator + (vector a)
{
   return vector (x + a.x, y + a.y);
}

vector vector::operator - (vector a)
{
   return vector (x - a.x, y - a.y);
}

vector vector::operator - ()
{
   return vector (-x, -y);
}

vector vector::operator * (double a)
{
   return vector (x * a, y * a);
}

double vector::module()
{
   return sqrt (x * x + y * y);
}

void vector::set_length (double a)
{
   double length = this->module();

   x = x / length * a;
   y = y / length * a;
}

ostream& operator {
   o    return o;
}

int main ()
{
   vector a;
   vector b;
   vector c (3, 5);

   a = c * 3;
   a = b + c;
   c = b - c + a + (b - a) * 7;
   c = -c;

   cout 
   cout    cout 
   c.set_length(2);            // Transforms c in a vector of size 2.

   a = vector (56, -3);
   b = vector (7, c.y);

   b.set_length();             // Transforms b in an unitary vector.

   cout 
   double k;
   k = vector(1, 1).module();  // k will contain 1.4142.
   cout 
   return 0;
}

Ji yra taip pat galima apibrėžti funkciją gamina dviejų vektorių suma be paminėti jį vektoriaus klasės apibrėžimas viduje. Tada jis bus ne iš klasės vektorių metodu, o tiesiog funkcija, kuri naudoja vektorius:

vector operator + (vector a, vector b)
{
   return vector (a.x + b.x, a.y + b.y);
}

Tuo atveju, kai visiškai klasės apibrėžimas Pavyzdžiui, kas išdėstyta, iš dvigubu vektoriaus daugyba apibrėžiama. Tarkime, mes norime dvigubos daugyba iš vektoriaus būti apibrėžtos taip pat. Tada mes turime parašyti izoliuotą funkciją lauko klasės:

vector operator * (double a, vector b)
{
   return vector (a * b.x, a * b.y);
}

Žinoma, raktiniais new ir delete darbą klasės atvejais taip pat. Kas daugiau, new automatiškai iškviečia konstruktorius siekiant inicijuoti objektus ir delete automatiškai iškviečia destructor prieš deallocating atmintį instancijoje kintamieji imtis:

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double = 0, double = 0);

   vector operator + (vector);
   vector operator - (vector);
   vector operator - ();
   vector operator * (double);
   double module();
   void set_length (double = 1);
};

vector::vector (double a, double b)
{
   x = a;
   y = b;
}

vector vector::operator + (vector a)
{
   return vector (x + a.x, y + a.y);
}

vector vector::operator - (vector a)
{
   return vector (x - a.x, y - a.y);
}

vector vector::operator - ()
{
    return vector (-x, -y);

}

vector vector::operator * (double a)
{
    return vector (a * x, a * y);
}

double vector::module()
{
   return sqrt (x * x + y * y);
}

void vector::set_length (double a)
{
   vector &the_vector = *this;

   double length = the_vector.module();

   x = x / length * a;
   y = y / length * a;
}

ostream& operator {
   o    return o;
}

int main ()
{
   vector c (3, 5);

   vector *r;                  // r is a pointer to a vector.

   r = new vector;             // new allocates the memory necessary
   cout // to hold a vectors' variable,
                               // calls the constructor who will
                               // initialize it to 0, 0. Then finally
                               // new returns the address of the vector.

   r->x = 94;
   r->y = 345;
   cout 
   *r = vector (94, 343);
   cout 
   *r = *r - c;
   r->set_length(3);
   cout 
   *r = (-c * 3  +  -*r * 4) * 5;
   cout 
   delete r;                   // Calls the vector destructor then
                               // frees the memory.

   r = &c;                     // r points towards vector c
   cout 
   r = new vector (78, 345);   // Creates a new vector.
   cout // The constructor will initialise
                               // the vector's x and y at 78 and 345

   cout x    cout 
   delete r;

   r = new vector[4];          // creates an array of 4 vectors

   r[3] = vector (4, 5);
   cout 
   delete [] r;                // deletes the array

   int n = 5;
   r = new vector[n];          // Cute!

   r[1] = vector (432, 3);
   cout 
   delete [] r;

   return 0;
}

24.

Vienas ar daugiau kintamųjų klasė gali būti paskelbta static. Tokiu atveju, pateikiamas tik vieną kartą tų kintamųjų egzistuoja, kurią turi visi klasės atvejais. Ji turi būti pradedamas ne klasės deklaracijoje:

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;
   static int count;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
      count++;
   }

   ~vector()
   {
      count--;
   }
};

int vector::count = 0;

int main ()
{
   cout 
   vector a;
   cout 
   vector b;
   cout 
   vector *r, *u;

   r = new vector;
   cout 
   u = new vector;
   cout 
   delete r;
   cout 
   delete u;
   cout 
   return 0;
}

25.

Klasė a kintamasis taip pat gali būti pastovus. Štai kaip statinio, išskyrus ji teikiama vertę klasės deklaracijoje viduje ir ta vertė negali būti pakeistas:

using namespace std;
#include 

class vector
{
public:

   double x;
   double y;
   const static double pi = 3.1415927;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   double cylinder_volume ()
   {
      return x * x / 4 * pi * y;
   }
};

int main()
{
   cout 
   vector k (3, 4);

   cout 
   return 0;
}

26.

Klasė gali būti IŠSKIRTA iš kitos klasės. Nauja klasė PAVELDI kintamuosius ir metodus PAGRINDINĖS KLASĖS. Papildomų kintamųjų ir/ar metodai gali būti pridėta:

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   double module()
   {
      return sqrt (x*x + y*y);
   }

   double surface()
   {
       return x * y;
   }
};

class trivector: public vector    // trivector is derived from vector
{
public:
   double z;                      // added to x and y from vector

   trivector (double m=0, double n=0, double p=0): vector (m, n)
   {
      z = p;                      // Vector constructor will
   }                              // be called before trivector
                                  // constructor, with parameters
                                  // m and n.

   trivector (vector a)           // What to do if a vector is
   {                              // cast to a trivector
      x = a.x;
      y = a.y;
      z = 0;
   }

   double module ()               // define module() for trivector
   {
      return sqrt (x*x + y*y + z*z);
   }

   double volume ()
   {
       return this->surface() * z;         // or x * y * z
   }
};

int main ()
{
   vector a (4, 5);
   trivector b (1, 2, 3);

   cout 
   cout    cout    cout 
   cout    cout    cout 
   trivector k;
   k = a;               // thanks to trivector(vector) definition
                        // copy of x and y,       k.z = 0
   vector j;
   j = b;               // copy of x and y.       b.z leaved out

   vector *r;
   r = &b;

   cout surface()    cout module() 
   return 0;
}

27.

Virš programos, r->module() skaičiuoja vektoriaus modulį, naudojant x ir y, nes r buvo paskelbtas vektoriaus rodyklę. Tas faktas, kad r tikrųjų taškų į trivector Netiksli atsižvelgta. Jei norite, kad programa patikrinti smailiu objekto tipą ir pasirinkti tinkamą metodą, tada jūs privalo deklaruoti šį metodą kaip virtualus viduje pagrindinės klasės.

(Jei ne mažiau kaip vienas iš pagrindinės klasės metodų yra virtualus tada "antraštę" 4 baitų įtraukta į kiekvieną iš klasių pavyzdžiui. Tai leidžia programą, kad nustatytų, kas yra vektorius iš tikrųjų nurodo.) (4 baitų yra tikriausiai įgyvendinimas konkretus. Ant 64 bitų įrenginio gal tai yra 8 baitai...)

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   virtual double module()
   {
      return sqrt (x*x + y*y);
   }
};

class trivector: public vector
{
public:
   double z;

   trivector (double m = 0, double n = 0, double p = 0)
   {
      x = m;                  // Just for the game,
      y = n;                  // here I do not call the vector
      z = p;                  // constructor and I make the
   }                          // trivector constructor do the
                              // whole job. Same result.

   double module ()
   {
      return sqrt (x*x + y*y + z*z);
   }
};

void test (vector &k)
{
    cout }

int main ()
{
   vector a (4, 5);
   trivector b (1, 2, 3);

   cout 
   vector *r;

   r = &a;
   cout module() 
   r = &b;
   cout module() 
   test (a);

   test (b);

   vector &s = b;

   cout 
   return 0;
}

28.

Gal jums įdomu, jei klasė gali būti gaunami iš daugiau kaip vienos bazinės klasės. Atsakymas yra "taip":

using namespace std;
#include 
#include 

class vector
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   double surface()
   {
      return fabs (x * y);
   }
};

class number
{
public:

   double z;

   number (double a)
   {
      z = a;
   }

   int is_negative ()
   {
      if (z       else       return 0;
   }
};

class trivector: public vector, public number
{
public:

   trivector(double a=0, double b=0, double c=0): vector(a,b), number(c)
   {
   }           // The trivector constructor calls the vector
               // constructor, then the number constructor,
               // and in this example does nothing more.

   double volume()
   {
      return fabs (x * y * z);
   }
};

int main ()
{
   trivector a(2, 3, -4);

   cout    cout    cout 
   return 0;
}

29.

Klasė išvedimas leidžia statyti daugiau sudėtingų klases pastatytas iš bazinių klasių. Yra ir kitas klasės išvedimą taikymas, leidžiantis programuotojas rašyti bendrosios funkcijos.

Tarkime, jūs apibrėžti pagrindinės klasės, be kintamųjų. Nėra jokios prasmės naudoti atvejus tos klasės viduje savo programą. Bet tada rašote funkciją, kurios tikslas yra rūšiuoti atvejų tos klasės. Kad funkcija bus rūšiuoti bet kurį iš objekto tipo, jeigu jis priklauso klasei, gautą iš pirmosios pagrindinės klasės gali! Vienintelė sąlyga yra ta, kad kiekvieno gauto klasės apibrėžimas vidų, visi metodai, kad rūšiavimo funkcija poreikiai teisingai apibrėžė:

using namespace std;
#include 
#include 

class octopus
{
public:

   virtual double module() = 0;  // = 0 implies function is not
                                 // defined. This makes instances
                                 // of this class cannot be declared.
};

double biggest_module (octopus &a, octopus &b, octopus &c)
{
    double r = a.module();
    if (b.module() > r) r = b.module();
    if (c.module() > r) r = c.module();
    return r;
}

class vector: public octopus
{
public:

   double x;
   double y;

   vector (double a = 0, double b = 0)
   {
      x = a;
      y = b;
   }

   double module()
   {
      return sqrt (x * x + y * y);
   }
};

class number: public octopus
{
public:

   double n;

   number (double a = 0)
   {
      n = a;
   }

   double module()
   {
      if (n >= 0) return n;
      else        return -n;
   }
};

int main ()
{
    vector k (1,2), m (6,7), n (100, 0);
    number p (5),   q (-3),  r (-150);

    cout     cout 
    cout 
   return 0;
}

Galbūt manote, kad "gerai, kad yra gera idėja gauti klases nuo klasės octopus, nes aš, kad taip gali taikyti jį atvejais iš mano klasės metodų ir funkcijos, kurios buvo suprojektuotos bendriniu būdu octopus klasės. Bet kas, jei ten dar viena bazė klasė, pavadinta cuttlefish, kuri turi labai įdomių metodus ir funkcijas per daug? Ar aš turiu padaryti, kad mano pasirinkimą tarp octopus ir cuttlefish, kai aš noriu gauti klasę? " Ne zinoma ne. Išvestinė klasė gali būti gaunami iš abiejų octopus ir cuttlefish. Štai POLIMORFIZMAS. Gautoji klasė paprasčiausiai turi apibrėžti metodus, būtinus octopus kartu su metodais, kurie yra būtini cuttlefish:

class octopus
{
   virtual double module() = 0;
};

class cuttlefish
{
   virtual int test() = 0;
};

class vector: public octopus, public cuttlefish
{
   double x;
   double y;

   double module ()
   {
      return sqrt (x * x + y * y);
   }

   int test ()
   {
      if (x > y) return 1;
      else       return 0;
   }
}

30.

public: direktyva reiškia kintamuosius arba gali būti pasiekiamos, ir naudojamas visur programoje žemiau metodai.

Jei norite, kad kintamieji ir metodai būtų prieinami tik metodų klasę IR metodus, gautų klases, tada turite įdėti raktažodį protected: prieš juos.

Jei norite kintamieji arba metodai, prieinama TIK metodų klasės, tada turite įdėti raktažodį private: prieš juos.

Tas faktas, kad kintamieji arba metodai yra deklaruojamos privatus ar apsaugotas reiškia, kad nieko išorės į klasę galima pasiekti arba naudoti juos. Štai KAPSULIAVIMAS. (Jei norite suteikti specialią funkciją teisę susipažinti su tomis kintamuosius ir metodus, tada turite įtraukti šią funkciją prototipas klasės apibrėžties, prieš kurį raktažodžių friend viduje).

Gera praktika yra sutraukti visus klasės kintamuosius. Tai gali skambėti keistai, jei esate pripratę prie structs C tiesų struct prasmę tik jei galite prieiti prie savo duomenų... C++ jūs turite sukurti metodus acces duomenų viduje klasėje. Toliau pateiktas pavyzdys naudoja pagrindinę pavyzdį, klasifikuojamų 17 skirsnyje, dar pareiškia, kad klasė duomenys turi būti saugomi:

using namespace std;
#include 

class vector
{
protected:

   double x;
   double y;

public:

   void set_x (int n)
   {
      x = n;
   }

   void set_y (int n)
   {
      y = n;
   }

 double surface ()
{
double s;
s = x * y;
if (s return s;
}
};

int main ()
{
vector a;

a.set_x (3);
 a.set_y (4);

cout 
return 0;
}

Aukščiau pateiktame pavyzdyje yra šiek tiek keista, nes klasės duomenis X ir Y gali būti nustatytas, bet jie negali būti skaityti atgal. Bet funkcija main () bandymas skaityti a.x arba a.y rezultatas bus kompiliavimo klaida. Kitame pavyzdyje, X ir Y gali būti skaityti atgal:

using namespace std;
#include 

class vector
{
protected:

   double x;
   double y;

public:

   void set_x (int n)
   {
      x = n;
   }

   void set_y (int n)
   {
      y = n;
   }

   double get_x ()
   {
      return x;
   }

   double get_y ()
   {
      return y;
   }

double surface ()
{
double s;
s = x * y;
if (s return s;
}
};

int main ()
{
vector a;

a.set_x (3);
a.set_y (4);

cout cout 
 cout 

return 0;
}

C++ kalba vienas neturėtų prieiti prie duomenų iš klasės tiesiogiai. Metodai turi būti deklaruojamos. Kodėl tai? Daug priežasčių egzistuoti. Vienas yra tai, kad leidžia jums pakeisti būdą duomenys yra atstovaujama klasėje. Kita priežastis yra tai leidžia duomenų klasės viduje cross-priklausomi. Tarkime, x ir y visada turi būti to paties ženklo, kitaip negraži dalykai gali atsitikti... Jei vienas yra leidžiama pasiekti klasės duomenis tiesiogiai, būtų lengva nustatyti pasakyti teigiamus x ir neigiamą m. Žemiau pateiktame pavyzdyje tai yra griežtai kontroliuojamas:

using namespace std;
#include 

int sign (double n)
{
   if (n >= 0) return 1;
   return -1;
}

class vector
{
protected:

   double x;
   double y;

public:

   void set_x (int n)
   {
      x = n;
      if (sign (x) != sign(y)) y = -y;
   }

   void set_y (int n)
   {
      y = n;
      if (sign (y) != sign(x)) x = -x;
   }

   double get_x ()
   {
      return x;
   }

   double get_y ()
   {
      return y;
   }

 double surface ()
{
double s;
s = x * y;
if (s return s;
}
};

int main ()
{
vector a;

a.set_x (-3);
a.set_y (4);

cout cout cout 
return 0;
}

31.

Pakalbėkime apie įvesties/išvesties. C++ kalba, kad tai labai plati tema.

Čia yra programa, kuri rašo į failą:

using namespace std;
#include 
#include 

int main ()
{
   fstream f;

   f.open("test.txt", ios::out);

   f 
   double a = 345;

   f  
   f.close();

   return 0;
}

Čia yra programa, kuri skaito iš failo:

using namespace std;
#include 
#include 

int main ()
{
   fstream f;
   char c;

   cout    cout 
   f.open("test.txt", ios::in);

   while (! f.eof() )
   {
      f.get(c);                          // Or c = f.get()
      cout    }

   f.close();

   return 0;
}

32.

Apskritai, tai yra įmanoma padaryti simbolių masyvai tuos pačius veiksmus, kaip ant failų. Tai labai naudinga konvertuoti duomenis arba valdyti atminties masyvus.

Čia yra programa, kuri rašo viduje simbolių masyvas:

using namespace std;
#include 
#include 
#include 
#include 

int main ()
{
   char a[1024];
   ostrstream b(a, 1024);

   b.seekp(0);                           // Start from first char.
   b // ( ends, not endl )
                                         // ends is simply the
                                         // null character   '\0'
   cout 
   double v = 2;

   strcpy (a, "A sinus: ");

   b.seekp(strlen (a));
   b 
   cout 
   return 0;
}

Programa, kuri skaito iš simbolių eilutę:

using namespace std;
#include 
#include 
#include 

int main ()
{
   char a[1024];
   istrstream b(a, 1024);

   strcpy (a, "45.656");

   double k, p;

   b.seekg(0);                       // Start from first character.
   b >> k;

   k = k + 1;

   cout 
   strcpy (a, "444.23 56.89");

   b.seekg(0);
   b >> k >> p;

   cout 
   return 0;
}

33.

Ši programa atlieka formato ir dviem skirtingais būdais. Atkreipkite dėmesį į width() ir setw() MODIFIKATORIAI yra veiksmingos tik kito elemento išėjimo į srautą. Vėlesni elementai nebus įtakos.

using namespace std;
#include 
#include 

int main ()
{
   int i;

   cout    for (i = 1; i    {
      cout.width (7);
      cout    }

   cout    for (i = 0; i    {
      cout    }

   return 0;
}

Dabar jūs turite pagrindinių žinių apie C++. Viduje gerų knygų jūs išmoksite daug daugiau dalykų. Failas valdymo sistema yra labai galingas, jis turi daug kitų galimybių, negu čia parodyta. Taip pat yra daug daugiau pasakyti apie klases: šablono klases, virtualiosios klasės...

Siekiant efektyviai dirbti su C++, jums reikės gera nuoroda knyga, kaip jums reikia vienas C. Taip pat reikia informacijos apie tai, kaip, C++ yra naudojami jūsų konkrečioje srityje veiklos. Standartai, pasaulio požiūris, gudrybės, tipiškas problemos ir jų sprendimai... Geriau

 

sias nuoroda yra žinoma knygos parašytos paties Bjarne Stroustrup (Nepamenu, kuris iš jų aš perskaičiau). Taip knyga yra beveik visos detales apie C ir C++, tai yra sukonstruotas tokiu būdu, panašiu į šį tekstą ir jame yra CD:

Jamsa's C/C++ Programmer's Bible
©right; 1998 Jamsa Press
Las Vegas, United States

Prancūzų kalba:
C/C++ La Bible du programmeur
Kris Jamsa, Ph.D - Lars Klander

France : Editions Eyrolles
www.eyrolles.com
Canada : Les Editions Reynald Goulet inc.
www.goulet.ca
ISBN 2-212-09058-7

Jis buvo prijungtas ir dabar:
Jamsa's C/C++/C# Programmer's Bible
Onword Press

Kita nuoroda:

accu:  www.accu.org/bookreviews/public/reviews/0hr/index.htm

CoderSource.net:  www.codersource.net

C++ Guide:  google-styleguide.googlecode.com/svn/trunk/cppguide.xml

C++ Reference: fresh2refresh.com/c/c-language-history

 

Panaši pamoka Ada yra prieinama www.adahome.com/Ammo/cpp2ada.html

"Haskell pamoka pagal C programuotojas: learnyouahaskell.com

 

Noriu padėkoti Didier Bizzarri, Toni Ronkko, Frédéric Cloth, Jack Lam, Morten Brix Pedersen, Elmer Fittery, Ana Yuseepi, William L. Dye, Bahjat F. Qaqish, Muthukumar Veluswamy, Marco Cimarosti, Jarrod Miller, Nikolaos Pothitos, Ralph Wu, Dave Abercrombie, Alex Pennington, Scott Marsden, Robert Krten, Dave Panter, Cihat Imamoglu, Bohdan Zograf, David L. Markowitz, Marko Pozner, Filip Zaludek ir Kevin Wheeler jų įkvėpimo, patarimai, pagalba, duomenų, ataskaitos apie klaidas, nuorodos, stiprinimas anglų teksto ir vertimo.

Ericas Brasseur - Vasario 23 1998 iki Birželio 4 2014

Originalus anglų kalba http://www.4p8.com/eric.brasseur/cppcen.html