Re: "The biggest advantage of X is the fact that it has automatic memory management." - Joel Spolsky

From:

Malinka <AelMalinka@gmail.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Tue, 21 Apr 2009 01:05:09 CST

Message-ID:

<dd2d7cb1-4107-425d-bedf-0667510e0e7e@j12g2000vbl.googlegroups.com>

On Apr 20, 3:50 pm, Piotr Dobrogost <p...@1.google.dobrogost.pl>
wrote:

Joel on Softwarehttp://www.joelonsoftware.com/articles/APIWar.html

"A lot of us thought in the 1990s that the big battle would be between
procedural and object oriented programming, and we thought that object
oriented programming would provide a big boost in programmer
productivity. I thought that, too. Some people still think that. It
turns out we were wrong. Object oriented programming is handy dandy,
but it's not really the productivity booster that was promised. The
real significant productivity advance we've had in programming has
been from languages which manage memory for you automatically. It can
be with reference counting or garbage collection; it can be Java,
Lisp, Visual Basic (even 1.0), Smalltalk, or any of a number of
scripting languages. If your programming language allows you to grab a
chunk of memory without thinking about how it's going to be released
when you're done with it, you're using a managed-memory language, and
you are going to be much more efficient than someone using a language
in which you have to explicitly manage memory. Whenever you hear
someone bragging about how productive their language is, they're
probably getting most of that productivity from the automated memory
management, even if they misattribute it."

Note to moderators:
I'd like to share this with C++ community as this is the main reason
new developers choose other languages over C++ whereas we all would
like it to be the other way around.

Piotr Dobrogost

A Managed int * in C++, just a food for thought response to your post
(c++ can work the way you described if that's how you design your
programs)

class A
{
    public: A();
            A(const A& rHand);
            A(const int &rHand);
            virtual ~A();
            int &operator * ();
            const int &operator * () const;
    private: int *ptr;
};

#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{
    A b(10);

    *b += 10;

    cout << *b << endl;

    return EXIT_SUCCESS;
}

A::A()
    : ptr(NULL)
{}

A::A(const A& rHand)
    : ptr(NULL)
{
    ptr = new int(*rHand.ptr);
}

A::A(const int &rHand)
    : ptr(NULL)
{
    ptr = new int(rHand);
}

A::~A()
{
    if(ptr != NULL)
        delete ptr;
    ptr = NULL;
}

int &A::operator *()
{
    return *ptr;
}

const int &A::operator *() const
{
    return *ptr;
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]