Why I don't spend time with Modern C++ anymore

Post by jonathankoren » Wed, May 18, 2016, 5:53 PM UTC

satysin wrote: post #168

jonathankoren wrote: post #33

I know why I don't like C++ anymore, it's just no fun.Its slow to compile, the errors are like 6 lines long full of template and class hierarchy that makes it hard to understand what exactly happened, and then of course there's the common coding shortcut of declaring everything auto. (What type is this list? I don't know, it's auto all the way down.) Then there's the whole thing about making constructors, but leaving…

shrugs I still like to code in C++. Beats having to use JS ;)

Post by mrich » Wed, May 18, 2016, 6:01 PM UTC

namelezz wrote: post #142

jupp0r wrote: post #57

In my experience, the opposite of what the author claims is true: modern C++ leads to code that's easier to understand, performs better and is easier to maintain. As an example, replacing boost::bind with lambdas allowed the compiler to inline functor calls and avoided virtual function calls in a large code base I've been working with, improving performance. Move semantics also boosted performance. Designing APIs wit…

> In my experience, the opposite of what the author claims is true: modern C++ leads to code that's easier to understand, performs better and is easier to maintain. Can you comment on the memory safety of modern C++? I am wondering if I should learn Rust or modern C++.

Post by fauigerzigerk » Wed, May 18, 2016, 6:26 PM UTC

lbrandy wrote: post #169

pcwalton wrote: post #157

Earlier quoted context omitted.

I never quite understood why unique_ptr and move semantics are supposed to improve memory safety over new and delete. They reduce leaks, sure, since the compiler inserts free for you at a hopefully-useful place. But you still effectively have to decide when to free, and there is no protection against dangling iterators, references, or pointers. From a security point of view, use after free is far worse than leaking,…

> I never quite understood why unique_ptr and move semantics... It's not those types, in particular, it's because C++11 allows you move your ownership model into the type system. And then, and this might sound familiar, writing code cognizant and explicit in its ownership semantics leads to safer, cleaner code.

Post by AnthonyMouse » Wed, May 18, 2016, 6:28 PM UTC

pcwalton wrote: post #157

PeCaN wrote: post #146

Earlier quoted context omitted.

std::unique_ptr, move constructors, etc and you're pretty safe, but it's still not in the same league as Rust. In my opinion you should probably learn Rust unless you want to get a job writing C++ (e.g. game development).

I never quite understood why unique_ptr and move semantics are supposed to improve memory safety over new and delete. They reduce leaks, sure, since the compiler inserts free for you at a hopefully-useful place. But you still effectively have to decide when to free, and there is no protection against dangling iterators, references, or pointers. From a security point of view, use after free is far worse than leaking,…

  class fail
  {
      foo * p;
      void init()
      {
         p->some_init();
         if(p->some_error())
         {
             delete p;
             throw some_exception();
         }
      }
  public:
      fail()
      {
          p = new foo;
          init();
      }
      ~fail()
      {
          delete p;
      }
      void reinit()
      {
          init();
      }
  };

  class ok
  {
       unique_ptr p;
       void init()
       {
           p->some_init();
           if(p->some_error())
           {
               throw some_exception();
           }
       }
  public:
       ok()
       {
            p = make_unique();
            init();
       }
       void reinit()
       {
            init();
       }
  };

Post by pcwalton » Wed, May 18, 2016, 6:28 PM UTC

lbrandy wrote: post #169

pcwalton wrote: post #157

Earlier quoted context omitted.

I never quite understood why unique_ptr and move semantics are supposed to improve memory safety over new and delete. They reduce leaks, sure, since the compiler inserts free for you at a hopefully-useful place. But you still effectively have to decide when to free, and there is no protection against dangling iterators, references, or pointers. From a security point of view, use after free is far worse than leaking,…

> I never quite understood why unique_ptr and move semantics... It's not those types, in particular, it's because C++11 allows you move your ownership model into the type system. And then, and this might sound familiar, writing code cognizant and explicit in its ownership semantics leads to safer, cleaner code.