Scribd Logo
Fazer o upload

Bem-vindo(a) ao Scribd!

  • Non Invariant CPP Algo - CPP

    Enviado por

    Vincenzo Comito
    2 visualizações8 páginas
    math and justice

    Título original

    non_invariant_cpp_algo.cpp

    Direitos autorais

    © © All Rights Reserved

    Formatos disponíveis

    TXT, PDF, TXT ou leia online no Scribd

    Você considera este documento útil?

    Este conteúdo é inapropriado?

    Denunciar este documento
    math and justice

    Direitos autorais:

    © All Rights Reserved
    Baixe no formato TXT, PDF, TXT ou leia online no Scribd
    Sinalizar o conteúdo como inadequado
    2 visualizações8 páginas

    Non Invariant CPP Algo - CPP

    Enviado por

    Vincenzo Comito
    math and justice

    Direitos autorais:

    © All Rights Reserved
    Baixe no formato TXT, PDF, TXT ou leia online no Scribd
    Sinalizar o conteúdo como inadequado
    de 8

    #include <iostream>

    A& a = ab;
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    }
    }
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {

    virtual void foo() override {


    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    #include <cstdlib>
    using namespace std;
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();

    AC ac = AC();
    A& a = ac;
    a.foo();
    {
    A& a = ab;
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    }
    }
    struct A {
    virtual void foo() = 0;

    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    {
    A& a = ab;
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };

    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    }
    }
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    struct A {

    virtual void foo() = 0;


    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    #include <cstdlib>
    using namespace std;
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    {
    A& a = ab;
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {

    cout << " hello AC " << endl;


    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();
    }
    }
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();

    A& a = ac;
    a.foo();
    struct A {
    virtual void foo() = 0;
    };
    struct AB : A {
    virtual void foo() override {
    cout << " hello AB " << endl;
    }
    };
    struct AC : A{
    virtual void foo() override {
    cout << " hello AC " << endl;
    }
    };
    int main() {
    AB ab = AB();
    AC ac = AC();
    A& a = ac;
    a.foo();

    Você também pode gostar