Различия между объектной моделью C++ и Java [закрыто]

многие из них охвачены философией дизайна.

во многих случаях Java запрещала практики, которые были опасны или не имели смысла большую часть времени. Например, нельзя вызвать метод из конструктора, поскольку нет никакой гарантии, что члены были инициализированы до завершения работы конструктора. Java пытается не допустить ссылки на объект, пока конструктор не будет завершен.

В C++ они обычно предполагают, что программист знает все потенциальные последствия его действий и позволяет им делать все, что они хотят.

также Java отбросил обратную совместимость C, вы не можете взять файл C и передать его компилятору Java.

остальные различия, вероятно, просто случаи, когда C++ был разработан до Java и Java узнал некоторые вещи из проблем, которые люди имели с C++. Точно так же C# имеет более чистый синтаксис или больше функциональности, чем Java в некоторых случаях, потому что они учились на Java.

Это разные языки. - как это для краткости.

название операции немного запутано. Такие вещи, как управление доступом, имеют мало общего с объектной моделью: это особенность системы управления доступом, которая является функцией времени компиляции. Последовательность построения объекта is часть объектной модели. Ключевое различие между C++ и Java заключается в том, что Java-это собранный мусор, а C++ - нет.

другое основное различие заключается в том, что Java использует архаичный crud для полиморфизма, тогда как C++ использует сломанный концепция шаблона: в шаблонах C++ время компиляции и не влияют на объектную модель, в Java полиморфизм взломан вокруг того, что в C++ называется динамическим приведением.

другое основное отличие заключается в том, что Java поддерживает потоки, тогда как в C++ вы должны использовать какую-то библиотеку.

существуют системные различия более низкого уровня: Java имеет минимальный статический тип, но в остальном является в основном динамическим языком. На C++ с другой стороны почти полностью статически типизированный язык, за исключением исключений ..:)

немного Java:

class Base
{
    public static void say( String s )
    {
        System.out.println( s );
    }

    public void sayHello()
    {
        say( "Base.sayHello says..." );
        say( "Base hello" );
    }

    public Base()
    {
        sayHello();
    }
}

class Derived
    extends Base
{
    private String[] myWords;   // = new String[]{ "Derived", "hello" };

    public void sayHello()
    {
        say( "Derived.sayHello says..." );
        say( myWords[0] + " " + myWords[1] );
    }

    Derived()
    {
        myWords = new String[]{ "Derived", "hello" };
    }
}

class ConsCallDemo
{
    public static void main( String[] args )
    {
        Derived o = new Derived();
    }
}

выход:

Derived.sayHello says...
Exception in thread "main" java.lang.NullPointerException
        at Derived.sayHello(conscall.java:28)
        at Base.(conscall.java:16)
        at Derived.(conscall.java:32)
        at ConsCallDemo.main(conscall.java:41)

проблема в том, что в Java вызовы спускаются к классу, из которого создается объект, еще до того, как этот экземпляр был инициализирован.

C++ защищает от этой проблемы, динамически настраивая тип объекта во время строительства и разрушения. В C++ объект имеет тип Base когда Base конструктор выполняет. Таким образом, звонки внутри Base конструктор ведет себя, если объект был создан из класса Base, независимо от фактического класса создания экземпляра.

пример этого, просто переводя код Java выше на C++:

#include <iostream>
#include <string>
#include <vector>
using namespace std;

void say( string const& s )
{
    cout << s << endl;
}

class Base
{
public:
    virtual void sayHello() const
    {
        say( "Base::sayHello says..." );
        say( "Base hello" );
    }

    Base()
    {
        sayHello();
    }
};

class Derived
    : Base
{
private:
    vector< string >    words_;

public:
    void sayHello() const
    {
        say( "Derived::sayHello says..." );
        say( words_[0] + " " + words_[1] );
    }

    Derived()
    {
        words_.push_back( "Derived" );
        words_.push_back( "hello" );
    }
};

int main()
{
    Derived o;
}

выход:

Base::sayHello says...
Base hello

один из способов получить вероятно предназначены эффект на C++, который также предлагает, как это сделать (правильно) на Java:

#include <iostream>
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
using namespace std;

void say( string const& s )
{
    cout << s << endl;
}

class Base
{
protected:
    struct Greeter
    {
        typedef boost::shared_ptr< Greeter >    Ptr;

        virtual void sayHello() const
        {
            say( "Base::sayHello says..." );
            say( "Base hello" );
        }
    };

private:
    Greeter::Ptr    greeter_;

public:
    void sayHello() const
    {
        greeter_->sayHello();
    }

    Base( Greeter::Ptr greeter = Greeter::Ptr( new Greeter ) )
        : greeter_( greeter )
    {
        sayHello();
    }
};

class Derived
    : Base
{
protected:
    struct Greeter
        : Base::Greeter
    {
        vector< string >    words_;

        virtual void sayHello() const
        {
            say( "Derived::sayHello says..." );
            say( words_[0] + " " + words_[1] );
        }

        Greeter()
        {
            words_.push_back( "Derived" );
            words_.push_back( "hello" );
        }
    };

public:
    Derived()
        : Base( Greeter::Ptr( new Greeter ) )
    {}
};

int main()
{
    Derived o;
}

выход:

Derived::sayHello says...
Derived hello

Что касается ваших других моментов, это слишком много обсуждать здесь. Просто имейте в виду, что C++0x будет поддерживать гораздо более практическую инициализацию, чем C++98. А также, что формальная сторона вашего пункта 7 немного оспаривается, есть отчет о дефекте об этом (это не было разрешено в предстандартном C++, как описано в Аннотированном справочном руководстве, но, по-видимому, это должно было быть разрешено в стандартном C98, однако формулировка немного противоречива).

Cheers & hth.,

около 7:

в Java я не могу сделать публичную функцию базового класса private в производном классе. Я был потрясен, увидев, что в C++ все в порядке и даже полезно.

Если вам удалось скрыть метод суперкласса, который не гарантирует, что ваш метод не может быть вызван пользователем. Всегда можно привести к суперклассу и вызвать метод, так как все нестатические методы в Java являются виртуальными методами C++, ваш метод подкласса фактически будет называемый.

Он будет работать со статическими методами, но я не думаю, что переопределение статических методов является хорошей практикой.

необходимость скрывать методы в подклассах обычно означает плохой дизайн, но если вам действительно нужно, вы должны создать исключение. Недостатком этого является то, что это время выполнения, но когда происходит вызов, он будет сбой. В то время как в C++, если вы скрываете метод, но приводите к родительскому классу, если его виртуальный метод будет фактически вызван, и если он статически связан метод родительского класса будет вызван, оба, вероятно, не то, что вы хотите.