2 beginner questions about c++

Question

1.what is the use of -> for exemple is test->name the same as test.name?

2.What are the header files used for? I am used to other programming language like java where you only need 1 file(the class file). Do we neessarily need to use a header file to declare all the stuff?

Answer 1

1. a->b is the same as (*a).b when a is a pointer. It's just convenient syntax for the same thing. When a is a class, it calls the operator-> of the class with a as the invoking object. If you don't understand that, then don't worry, when you get further in C++ you will.
2. Header files are to contain declarations while .cpp files contain the definitions. You need them when you want to write functions that can be used from other files. This is because you can have as many declarations of a structure (that is, a variable, function, class, etc) as you want, but only one definition of that structure. Header files are included many places in the code (by every file that needs to use the facilities its implementation provides) and are compiled once for every .cpp file that includes them, so it wouldn't do to put anything you can only have one of in a header file. Implementation files (.cpp or .c files) are only compiled once for the whole program, so they are the right place for the implementations (things that you can only have one of). Header files are also to facilitate the seperation of implementation and interface.

However, all these questions would have been answered by a good C++ book, so please buy and read one before going too far, it'll save a lot of time and headache.

Answer 2

structure->member

is the equivalent of

(*structure).member

thus, it is a shortcut. It dereferences the pointer structure and accesses member member

Answer 3

1) The "arrow" operator -> is not the same as the operator ., but a shortcut when you use pointers to structs instead of just structs. See this explanation, for example:

struct Point {
    int x;
    int y;
};

Point* p;      // p points to a Point struct

p = new Point;
p->x = 12;     // This is an useful shortcut for...
(*p).x = 12;   // .. this

2) About header files, they aren't necessary, you can also add the declarations at the beginning of the .c file, but it's an useful convention to have declarations and actual code seperated.

Answer 4

Well, I will try to explain in a simple way to make it easier for a beginner to understand better.

1. Yes, it's the same as dot, but it's used for pointers.

   MyClass a;
   a.myMethod();
   
   MyClass* b = new MyClass;
   b->myMethod();
   delete b;
   

   Both a and b call the same method, but a is allocated in the heap and b is a pointer allocated by new. Memory explicity allocated should always be deallocated (thus the delete b statement). This is actually a simplification, what the arrow does is dereference the pointer and call the dot operator over it. If this makes your head spin at the moment, just take the simple explanation for now, it will sink later as you became more acostumated with the language.

2. Header files are not obligatory, but they are usefull to reference what was declared in translation unit in another one. So, for example, you declare MyClass in a header, than you can use it in both myfilea.cpp and myfileb.cpp without too much effort having to declare it more than once.

   To properly understand the header files you need to know that when you use statements like:

   #include "myheader.h"
   

   What the compiler's preprocessor does is copy and paste all the contents of myheader.h into the file that included it. Since the compiler needs to know about the types (usually classes) before letting you use them, in each file you need to "redeclare what the types are". It's entierely possible to implement everything inside the header file actually, similar to what would look like a Java code, then in one main.cpp file include those files, but then the code would take a lot longer to compile and would be harder to follow.

Answer 5

I think you need to read a book on C++ and C, '->' is not the same as '.' but almost, and header files has to do with the compiler, and the memory layout. C++ is alot more about the actual machine than java, and the means that you have to thinkabout programming in a slightly different way.

I recommend reading Bjarne Staustrups book on C++, or at least browse through it. If C++ was just Java with another syntax there would have been no reason to invent Java -- The languages each have their applications and you need to understand what the language is about before you start using it. :-)

Answer 6

std::string str("foo");
std::string *str_p=new std::string("bar");   /
//Please use smart pointers in real code
std::cout <<  str.size() << "   " << str_p->size();

so basically -> deferences a pointer than access a member of the type.

It is equivelent too

(*str_p).size(); 

here str_p is first dereferenced manually then the size member function in invoked.

Answer 7

1. test->name is completely equal to (*test).name , not test.name
2. The headers are used to include the same definition in many translation units, Java don’t use them because definitions are never required, all objects are used by pointers.

Look at this example:

class A
{
   B member;
};

If you don’t include the definition of B, you cannot know the size of class A. In java, member would be a pointer, so this is useless.