next »

[Will Vale]

and process it by reference.

Thanks, that's what I was curious about. I agree that owning data by value is desirable, although it does imply (in C++) a degree of dependency (#include rather than forward-declare) which you could otherwise avoid. But maybe that's a reasonable price to pay for the degree of transparency and simplicity you get.

Will

[BlueSweatshirt]

What do you guys exactly mean by "owning data by value" as opposed to by reference?

[Sakar]

What do you guys exactly mean by "owning data by value" as opposed to by reference?

This is probably a bad explanation, but here it goes:

Owning data by value means that something owns the actual value of the data, like the value a pointer points to. By reference means something holds a reference to it, like a pointer points to memory, but doesn't actual have it.

Basically its like the difference between pointers and normal variables

[Will Vale]

That's about right. Maybe a bit of code will help too:

Code:

struct Bullet
{
  float x, y;
};

// Bullets by reference - we point to (refer to) bullets in memory somewhere.
std::vector<Bullet*> bullet_references;

// Bullets by value - we have the complete bullet states (values) right here.
std::vector<Bullet> bullet_values;

[BlueSweatshirt]

Oh.

I was under the impression you guys were talking about something way different.

[Will Vale]

Unfortunately C++ is mired in jargon. For instance, the appallingly-named RAII (Resource Acquisition Is Initialisation) means more-or-less "acquire things you need in constructors, release them again in destructors". I can't think of a more opaque name for it than RAII

Code:

class File
{
public:
   File( const char *name ) : fp(fopen(name, "rb")) {}
   ~File() { fclose(fp); }

private:
   FILE *fp;
};

[paste]

Owning data by value means that something owns the actual value of the data, like the value a pointer points to. By reference means something holds a reference to it, like a pointer points to memory, but doesn't actual have it.

Basically its like the difference between pointers and normal variables

What's the benefit of it?  Less memory leaks and easier readability I'm guessing? Why use pointers at all then?

[PompiPompi]

You "have" to use pointers. If you want an array that change it's size at run time, you "have" to use pointers. If you want a linked list, you "have" to use pointers.
The thing is, you don't have to use '*' in many cases. But you can use STL(Standard Template Library) which implement many of the things requiring pointers, for you.
So when you want a linked list, you just do std::list<T>, instead of some struct Node { Node * Next;}
Some mentioned boost, I actually don't like to use boost if I don't have to. I think smart pointers should be used mostly when seperate your program into modules.
So basically, you can avoid using '*' in many cases, but behind the scenes, when you use std::vector and std::list, there will be a pointer hidden in their implementation somewhere.

[Skomakar'n]

sometimes obscure C++ knowledge. (E.g., "Explain what the 'mutable' keyword does.")

Mutable isn't obscure. Volatile is.

@Average Software: I've been reading that Stroustrup book on and off lately. What book would you recommend for C? I'm guessing Kernighan and Ritchie's? What do you mean by "a proud language lawyer"? Why aren't I asking you this stuff on IRC?

Because if you ask it in this thread, the eventual reply will remain here for anyone to see and benefit from, which is a mighty fine thing.

[Klaim]

Unfortunately C++ is mired in jargon. For instance, the appallingly-named RAII (Resource Acquisition Is Initialisation) means more-or-less "acquire things you need in constructors, release them again in destructors". I can't think of a more opaque name for it than RAII

RAII name comes from Stroustup that himself says that he's really not good at "marketing" and should have asked someone else for another name. The problem is that the term is already widely used in C++-specific circles...

It would be nice to have a better name, but oh well...

[rivon]

You "have" to use pointers. If you want an array that change it's size at run time, you "have" to use pointers. If you want a linked list, you "have" to use pointers.
The thing is, you don't have to use '*' in many cases. But you can use STL(Standard Template Library) which implement many of the things requiring pointers, for you.
So when you want a linked list, you just do std::list<T>, instead of some struct Node { Node * Next;}
Some mentioned boost, I actually don't like to use boost if I don't have to. I think smart pointers should be used mostly when seperate your program into modules.
So basically, you can avoid using '*' in many cases, but behind the scenes, when you use std::vector and std::list, there will be a pointer hidden in their implementation somewhere.

You also need pointers when you plan to use a lot of data as stack memory is limited and therefore you need to allocate memory for the data on heap.

sometimes obscure C++ knowledge. (E.g., "Explain what the 'mutable' keyword does.")

Mutable isn't obscure. Volatile is.

I don't know either and I never ever needed it

[Average Software]

sometimes obscure C++ knowledge. (E.g., "Explain what the 'mutable' keyword does.")

Mutable isn't obscure. Volatile is.

I don't know either and I never ever needed it

I use mutable quite often, and there are lots of neat tricks you can do with volatile overloading.  I once wrote a queue class that was mutex locked for concurrent access if you declared it to be volatile.

Outside of embedded programming and some concurrency situations though, volatile probably doesn't see a lot of use.

Truly obscure, at least for me, were bitfields.

Code:

struct Bitfield
{
    unsigned bit_1 : 1;
    unsigned bit_2 : 1;
    unsigned two_bits: 2;
};

I'm not going to explain that code, look it up if you're interested.

[Moczan]

Wow, I'm not really a C++ expert, but I always thought that bits being fundamental to programming, using bitfields and bitwise operators was common.

[peous]

No, usually it's not useful to know bits when using C++
About volatile, the problem is that implementation can be compiler dependent, and optimization-level dependant, so I usually don't use it

[rivon]

You don't generally work directly with bits unless you're doing encryption or compression or something like that.