Should I use -> or . ?

**Mario F.** · 07-21-2009

Originally Posted by brewbuck

In other words, if the LHS is a pointer, magically transform "." into "->".

Well, here you have the first problem. Code semantics are being hidden away, making the code less clear. And isn't this precisely what should be avoided on a strongly typed language? And wouldn't that just complicate the compiler's life too?

I believe we can agree (*ptr).member() needs an alternative. However, I don't think it ever crossed anyone's mind to replace it with the dereference operator simply because there is important information that suddenly is lost and a semantics contract being broken.

But if you accept that argument, then you should also accept that C++ references are equally confusing because they "magically" dereference themselves wherever they are used, and are difficult to distinguish in precisely the same way.

Absolutely not!

You may look at references as const pointers, but regardless of how they are implemented by the compiler, their semantics are vastly different. A reference is never dereferenced. Or to put it bluntly, a reference is not a pointer, it is a reference.

**brewbuck** · 07-21-2009

Originally Posted by Mario F.

Absolutely not!

You may look at references as const pointers, but regardless of how they are implemented by the compiler, their semantics are vastly different. A reference is never dereferenced. Or to put it bluntly, a reference is not a pointer, it is a reference.

My point is, in the following code snippet, can you tell me whether x is a reference to an object, or an actual object?

Code:

foo.bar();

I don't see how that's different from asking, is foo an object or a pointer to an object?

**Kudose** · 07-21-2009

I have another question about header files ... I have been searching and cannot figure this out.

testing.h

Code:

#ifndef TESTING_H
#define TESTING_H

int test();

#endif

testing.cpp

Code:

#include "testing.h"

int test(){
  return 3;
}

test.cpp

Code:

#include<iostream>
#include "testing.h"

int main(){
  
  std::cout << test();
  
  system("PAUSE");
  return 0;
}

[Linker error] undefined reference to `test()' using Dev-C++

Does anyone know why I would get this?

TIA!

**Daved** · 07-21-2009

If you're building with a project, you have to include both testing.cpp and test.cpp in the project so both can be compiled and then linked together.

As it is, you are only compiling test.cpp, which can see the declaration for test() but cannot link to the definition.

**Elysia** · 07-21-2009

Aside from the linking issue, Dev-C++ is a bit outdated. I would recommend a new IDE.
Some good IDEs that are available can be found at: http://cpwiki.sf.net/IDE
Visual Studio and Code::Blocks are two favorites.

**Thantos** · 07-21-2009

Originally Posted by brewbuck

My point is, in the following code snippet, can you tell me whether x is a reference to an object, or an actual object?

Code:

foo.bar();

I don't see how that's different from asking, is foo an object or a pointer to an object?

References and pointers have different semantics though. Asking if something is an object or an alias (aka reference) of that object really doesn't matter. Thantos is a reference to me, so if you address me as Thantos or as my real name it doesn't really make any difference.

**Mario F.** · 07-21-2009

Originally Posted by brewbuck

My point is, in the following code snippet, can you tell me whether x is a reference to an object, or an actual object?

Code:

foo.bar();

I don't see how that's different from asking, is foo an object or a pointer to an object?

Ah, I see you point.
I don't have the vocabulary to put this in the right words. But I believe it is largely irrelevant to know if it is a reference or the actual object, since any operator semantics remain the same.

However, * and -> offer vastly different semantics. Let me remind you of their overload declarations:

Code:

myClass &operator*() { /*...*/ }
myClass *operator->() { /*...*/ }
const myClass &operator*() const { /*...*/ }
const myClass *operator->() const { /*...*/ }

**Daved** · 07-21-2009

>> Asking if something is an object or an alias (aka reference) of that object really doesn't matter.
When an object goes out of scope, it is destroyed. When a reference (or alias) goes out of scope, the object is not destroyed. That is as much of a difference as the difference between a pointer and an object with respect to this question.

>> However, * and -> offer vastly different semantics.
The question was between . and ->, not * and ->.

**Kudose** · 07-21-2009

Installed Code::Blocks ... looks like a winner.

I got everything up and running. Thanks for everyone's help and the interesting reading!

**VirtualAce** · 07-21-2009

And never ever include .cpp files. They are compiled separately. Header files can be included.

You can include .cpp files as .inl or as .hpp when using templates if you want to put your definitions in a separate file. I prefer .inl but I have seen it done as .cpp.

**Hussain Hani** · 07-21-2009

btw, the "blood type" function is implemented wrong
you can't just make a char pointer data member point at another char
you gotta allocate an indepent piece of memory for it

**Daved** · 07-21-2009

>> you can't just make a char pointer data member point at another char
In this case you can, because they are all pointers to string literals.

They should be const char* variables which would make this more clear, but it's still legal as is and should work.

**CornedBee** · 07-22-2009

Originally Posted by brewbuck

My point is, in the following code snippet, can you tell me whether x is a reference to an object, or an actual object?

Code:

foo.bar();

I don't see how that's different from asking, is foo an object or a pointer to an object?

The pointer could be null. This is the most significant difference between references and pointers: references cannot ever be null, and if you use them properly, they cannot ever be invalid either. A pointer, on the other hand, can be null, and it's not uncommon for it to be invalid either.

Thus, dereferencing a reference can be implicit (by using the value directly or by using the direct member access operator), whereas dereferencing a pointer really should always be explicit, using * or ->.

**Brafil** · 07-22-2009

Well, my GCC allows a NULL reference:

Code:

#include <iostream>

int main(void)
{
    int &ref = *(int *)0;
    std::cout << "&ref is 0" << std::endl;
    std::cout << "ref is now " << ref << std::endl;
}

The code crashes after printing "&ref is now 0". That's not standard, is it?