Smart pointers

What does /prog/ think of smart pointers?

What do smart pointers think of /prog/?

>>2
they are too smart to care about /prog/

also /prog/ is shit! acording to them

>>1
As a C++ programmer, I think they are nice.

They're good for directed acyclic graphs. Stack memory, tracing garbage collectors and manual memory management are better for other purposes.

on a scale from 1 to 10 i would rate them a "meh"

They're great. You should always use them unless you have an explicit reason not to. You can always go back and change them to raw pointers.

Smart pointers, for stupid programmers.

>>8
Enjoy your exception unsafe leaky code, luddite.

Poor man's GC, or retarded man's high level language?

>>9
example to >>8

Smart pointers are smarter than most of their users

>>10
>>11
>>12
>>8
Fucking retarded. See:

http://herbsutter.com/elements-of-modern-c-style/

>>13
one day, after looking up from the ashes of a double nested cyclic backwards up pointer destroyer auto self intertwined destructor callback cascade, you may appreciate explicit code for simple tasks.

C++ is just Common Lisp done wrong.

>>14
I agree with this completely. It applies even more when you have to debug something that fails somewhere inside the 'hidden' code the compiler automatically generates.

C doesn't have this problem because it's limited in terms of automatically generating code. With C++, things like constructor and destructor calls are generated automatically, and composing deeply nested objects with lots of composition can increase this hidden complexity to surprisingly high levels. Add templated classes (consisting of templated members and superclasses), and it multiplies even more.

Hiding complexity may make things look simpler on the surface, but frustrates understanding of the code, an essential point when debugging. Moreover, the concept of "informed decisions", another important aspect of why C is used --- because it lets the programmer understand the implications of her code easily --- by definition is based upon having knowledge of such details. C++ makes this slightly more difficult due to the autogenerated code, C++11 is going to make it worse.

When auto x = something() looks nearly the same as int x = something(), when a "smart pointer" looks nearly the same as a regular pointer, you've lost that information. Without that information, you've lost the ability to make an informed decision.

The aforementioned new features make it much easier to create lots of code, but make it correspondingly harder to understand it.

"With great power comes great responsibility."

>>16
so are you saying smart pointers are bad if you are a bad programmer that lot's of bugs?

>>16
The higher level languages are easier to optimise for a compiler because the compiler can apply different techniques for more abstract code. C++ is a special case where this rule doesn't apply because C++ is a clusterfuck of features.

>>17
Could-er is a silly, silly person, but you are an even sillier person Anonymous.

You are more silly than a person that has a whitespace in his name, now that is silly!

>>18
0/10

>>16
her code
Stopped reading right there. Use Spivak pronouns.

check em

>>22
nice dubz bro. I hope I can get such delicious dubz in my life

well hmm i wonder what smart pointers are

>In computer science, a smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic garbage collection or bounds checking.

>automatic garbage collection or bounds checking.

hahahahahahahahaha

y dose my thing have mem leak/??? seg fault WTF??? btr use smart ptrs 2 b safe...

What's a pointer? Why do I need them?

>>23
Try this thread: http://dis.4chan.org/read/prog/1338507812/

>>17
it doesn't take much to accidentally trigger a double nested cyclic backwards up pointer destroyer auto self intertwined destructor callback cascade.

>>20
It's actually true. In seeples, the decision to use a pointer, a reference counted pointer, or unique pointer, or allocation on the stack, is a decision that you must make, and your design must remain completely consistent with this decision.

In a memory managed language, you create some kind of object and use it for a while, and possibly pass around references to it. If no references are able to escape the body of the function, the compiler can allocate the object on the stack. If it can be shown that no cyclic references back to the object can occur, then reference counting is sufficient. This is guaranteed when the object contains no reference to other objects, or if all referenced objects are immutable, and the references were all initialed once when the object was created. These are easy for the compiler to determine when these concepts are a part of the language. But there are times when reference counting works, but is more difficult to verify. Unique pointers are shit.

Would /prog/ consider it good practice to use shared_ptr everywhere while you're developing/debugging, and then when you're ready to ship, go back and carefully convert them to new'd and delete'd raw pointers?

>>28
don't you think if a human could do that and not fuck it up, a computer might be able to as well?

>>29
yeah but it's more time efficient because you don't have to fuck around with memory while working on problems; you can focus on memory later

>>30
disregard that, i suck cocks

Smart pointers are for idiots.

Preallocate large linear blocks of memory and use homogenous arrays for optimal cache usage. Use the standard malloc/free heap functions elsewhere for the small amount of data that doesn't have strict and easily determinable life spans.

http://gamesfromwithin.com/data-oriented-design

smart doubles

His continuum hypothesis is the proposition that ???? is the same as ℵ₁. This hypothesis has been found to be independent of the standard axioms of mathematical set theory; it can neither be proved nor disproved from the standard assumptions.

null laser pointers

The continuum hypothesis (CH) states that there are no cardinals strictly between ℵ₀ and 2^ℵ₀. The latter cardinal number is also often denoted by ????; it is the cardinality of the continuum (the set of real numbers). In this case 2^ℵ₀ = ℵ₁. The generalized continuum hypothesis (GCH) states that for every infinite set X, there are no cardinals strictly between | X | and 2^{| X |}. The continuum hypothesis is independent of the usual axioms of set theory, the Zermelo-Fraenkel axioms together with the axiom of choice (ZFC).

Physicists however require that the end result be physically meaningful. In quantum field theory infinities arise which need to be interpreted in such a way as to lead to a physically meaningful result, a process called renormalization.

General set theory, a small fragment of Zermelo set theory sufficient for the Peano axioms and finite sets;

ZF set theory does not formalize the notion of classes. They can instead be described in the metalanguage, as equivalence classes of logical formulas. For example, if \mathcal A is a structure interpreting ZF, then the metalanguage expression \{x\mid x=x \} is interpreted in \mathcal A by the collection of all the elements from the domain of \mathcal A; that is, all the sets in \mathcal A. So we can identify the "class of all sets" with the predicate x=x or any equivalent predicate.