Teknologian jakaminen

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Johdatus koostumukseen ja vertailu perintöön

mikä on yhdistelmä
(1) Koostumus tarkoittaa useiden muiden luokkien objektien käyttämistä jäseninä luokan sisällä.
(2) Käytä luokkapuuta tapausten selittämiseen
(3) Yhdistelmä on myös koodin uudelleenkäyttömenetelmä, ja sen ydin onRakenneSisältää

#include <iostream>
#include <vector>
#include <string>

// Leaf 类
class Leaf {
public:
    Leaf(const std::string& color) : color_(color) {
        std::cout << "Leaf constructor called: " << color_ << std::endl;
    }

    ~Leaf() {
        std::cout << "Leaf destructor called: " << color_ << std::endl;
    }

    void display() const {
        std::cout << "Leaf color: " << color_ << std::endl;
    }

private:
    std::string color_;
};

// Branch 类
class Branch {
public:
    Branch(int length) : length_(length) {
        std::cout << "Branch constructor called: " << length_ << " cm" << std::endl;
    }

    ~Branch() {
        std::cout << "Branch destructor called: " << length_ << " cm" << std::endl;
    }

    void display() const {
        std::cout << "Branch length: " << length_ << " cm" << std::endl;
    }

private:
    int length_;
};

// Tree 类，包含 Leaf 和 Branch 对象
class Tree {
public:
    Tree(const std::string& leafColor, int branchLength) 
        : leaf_(leafColor), branch_(branchLength) {
        std::cout << "Tree constructor called" << std::endl;
    }

    ~Tree() {
        std::cout << "Tree destructor called" << std::endl;
    }

    void display() const {
        leaf_.display();
        branch_.display();
    }

private:
    Leaf leaf_;
    Branch branch_;
};

int main() {
    Tree tree("Green", 150);
    tree.display();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

Perinnön ja koostumuksen ominaisuuksien vertailu
(1) Perintö on eräänlainen (On a) Suhde on transitiivinen eikä symmetrinen.
(2) Yhdistelmä on osan suhde (on a),
(3) Perintö on valkoisen laatikon uudelleenkäyttöä. Koska luokan periytymisen avulla voimme ohittaa yläluokan toteutustiedot oman toteutuksemme mukaan, yläluokan toteutus näkyy alaluokalla.
(4) Perinnön valkoisen laatikon uudelleenkäyttöominaisuus tuhoaa jossain määrin luokan kapselointiominaisuuden, koska se paljastaa emoluokan toteutustiedot alaluokalle.
(5) Yhdistelmä kuuluu mustan laatikon uudelleenkäyttöön.Sisältyneen objektin sisäiset yksityiskohdat ovat näkymättömiä ulkomaailmalle, joten sen kapselointi on suhteellisen hyvä ja keskinäinen riippuvuus toteutuksessa on suhteellisen pieni.
(6) Yhdistelmään sisältyvä luokka luodaan ja tuhotaan, kun sisältävä luokka luodaan. Yhdistelmät ovat mustan laatikon uudelleenkäyttöä, ja ne voidaan määrittää dynaamisesti ajon aikana hankkimalla muita samantyyppisiä objektiviittauksia tai osoittimia. Haittapuolena on, että järjestelmässä on liikaa kohteita.
(7) OO-suunnitteluperiaate on yhdistää ensin, sitten periä.

Moniperintö ja sen moniselitteisyysongelmat

moninkertainen perintö
(1) Moniperintö tarkoittaa, että alaluokalla on useita yläluokkia
(2) Usean periytymisen esittely
(3) Moniperinnön ja yksittäisperinnön periaatteiden välillä ei ole selvää eroa.
(4) Moninkertainen periytyminen voi johtaa moniselitteisyysongelmiin
Moniperinnön moniselitteisyys 1
(1) Skenaario: C:llä on useita perintöjä A:sta ja B:stä, joten on epäselvyyttä kutsuttaessa jäseniä, joilla on samat nimet A ja B C:ssä.
(2) Syy: C perii samannimisen jäsenen (eri nimiavaruusalue) A:lta ja B:ltä, joten C:n objektilla kutsuttaessa kääntäjä ei voi määrittää kumpaa haluamme kutsua.
(3) Ratkaisu 1: Välttääksesi tapahtuman, älä anna A:n ja B:n julkisten jäsenten nimeämisen olla ristiriidassa toistuvasti. Mutta tämä on joskus hallitsematonta.
(4) Ratkaisu 2: Määritä selkeästi, kumpaa kutsua koodattaessa. Käytä cA::func() määrittääksesi selvästi, että luokan A funktiota kutsutaan luokan B funktion sijaan.
(5) Ratkaisu 3: Määritä funktio uudelleen C:ssä, jolloin C:n funktio kutsutaan ja A:n ja B:n funktio piilotetaan.
(6) Yhteenveto: Se voidaan ratkaista, mutta hyvää ratkaisua ei ole.

Moniperinnön moniselitteisyys 2
(1) Skenaario: timanttien periytymisongelma.Toisin sanoen A on esi-isäluokka, B1:A, B2:A, C:B1,B2 Tällä hetkellä on epäselvyyttä, kun C:n objektia käytetään kutsumaan menetelmää A:ssa.
(2) Analyysi: c.func() on moniselitteinen, cA::func() on myös epäselvä, mutta c.B1::func() ja c.B2::func() eivät ole moniselitteisiä
(3) Ratkaisu: Sama kuin tehtävä 1, mutta tehtävä 2 on hienovaraisempi ja vaikeampi välttää

// 祖类
class Aa {
 public:
  void show() { std::cout << "A's method" << std::endl; }
};

// 派生类 B1 和 B2，从 A 继承
class B1 : public Aa {
 public:
  void show() { std::cout << "B1's show" << std::endl; }
  void showB1() { std::cout << "B1's method" << std::endl; }
};

class B2 : public Aa {
 public:
  void show() { std::cout << "B2's show" << std::endl; }
  void showB2() { std::cout << "B2's method" << std::endl; }
};

// 派生类 C，从 B1 和 B2 继承
class C : public B1, public B2 {
 public:
  void showC() { std::cout << "C's method" << std::endl; }
};

int test070103() {
  C c;
  // c.Aa::show();    // 调用 A 的方法 不可以
  c.Aa::B1::show();  // 调用 A 的方法 不可以
  c.B2::Aa::show();  // 调用 A 的方法 不可以
  c.B1::show();      // 调用 B1 的方法
  c.B2::show();      // 调用 B2 的方法
  c.showB1();        // 调用 B1 的方法
  c.showB2();        // 调用 B2 的方法
  c.showC();         // 调用 C 的方法
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

Virtuaalinen perintö ratkaisee timanttiperinnön moniselitteisyysongelman

Kuinka käyttää virtuaalista perintöä
(1) Skenaario: Timanttiperintö johtaa epäselvyysongelmiin. Pohjimmiltaan on kaksi A-objektia, jotka sisältyvät lapsenlapsiluokan C luokkaan B1 ja B2, joten epäselvyyttä on olemassa.
(2) Virtuaalinen periytymisratkaisu: Olkoon B1 ja B2 perivät A virtuaalisesti, ja sitten C voi periä B1 ja B2 normaalisti.
(3) Virtuaalinen periytyminen on niin yksinkertaista, että se on luotu ratkaisemaan timanttiperinnön ongelma. Sillä ei ole suoraa yhteyttä virtuaalisiin toimintoihin (polymorfisten ominaisuuksien saavuttamiseksi).

Virtuaaliperinnön toteutusperiaate
(1) Virtuaaliperinnön periaate on: virtuaalinen perusluokan taulukkoosoitin vbptr ja virtuaalinen perusluokan taulukko virtuaalitaulukko
(2)Viite:https://blog.csdn.net/xiejingfa/article/details/48028491

Tee yhteenveto

Ymmärrä, mikä yhdistelmä on Luokassa on monia muiden luokkatyyppien jäsenmuuttujia.
Ymmärrä ero koostumuksen ja perinnön välillä
Epäselvyys: Jos suoritat funktion, se ei välttämättä ole se, jonka haluat määrittää.
Ratkaisu: Käytä cA::func() määrittääksesi kutsuttavan luokan
Virtuaalinen periytyminen on vähän kuin ehdollinen käännös. Sitä ei tarvitse ottaa käyttöön toistuvasti käyttöönottovaikutuksen saavuttamiseksi.

Tutkimustiedot ja rikkomusyhteystiedot poistetaan.
Lähde: Teacher Zhu’s Internet of Things Classroom