Inline Members

Sorry for such a simple question. I just want to clarify something.

If a method is defined inside the class declaration, it's automatically considered inline, correct? This would mean that I should avoid doing so except for very simple methods or constructors.

I'm pretty confident about this, but I'm looking at a large amount of code from a program here where all of the class methods are defined inside the class declaration and it didn't make sense to me. The best choice if you don't want to separate the implementation from the declaration would be to define the methods inside the header file, but outside the class declaration, right?

Thanks.

Quote:

---

Originally Posted by Raislin

If a method is defined inside the class declaration, it's automatically considered inline, correct?

---

Yes, though more precisely you mean class definition rather than class declarations in general.

Quote:

---

Originally Posted by Raislin

This would mean that I should avoid doing so except for very simple methods or constructors.

---

Note that the compiler has the option of not inlining despite your suggestion that it do so.

What's the difference between declaration and definition as far as classes go? I'm not sure I'm getting that.

Quote:

---

Originally Posted by Raislin

What's the difference between declaration and definition as far as classes go?

---

A definition is a declaration, but a declaration can also refer to a forward declaration such as:

Code:

---

class X;

---

Look at example for function declaration and function definition.

That makes sense.

Quote:

---

Originally Posted by laserlight

A definition is a declaration, but a declaration can also refer to a forward declaration such as:

Code:

---

class X;

---

---

I always thought that the stuff in header file (class name, its members function etc) is a declaration whereas the definitions are the details of those declarations that go in .cpp file. Is it incorrect to think of it this way?

sgiri

Quote:

---

Originally Posted by sgiri1981

I always thought that the stuff in header file (class name, its members function etc) is a declaration whereas the definitions are the details of those declarations that go in .cpp file. Is it incorrect to think of it this way?

---

For functions, yes. For structs and classes, no.

EDIT:
Well, that probably deserves some elaboration.
In general, a declaration tells the compiler that something exists. You can then refer to what you have declared and the compiler accepts it, because you've told it that it exists.
A definition actually creates something (be it a variable, function, class, ...). It is the task of the linker to relate whatever you referred to in your code, to whatever you created.

E.g.

Code:

---

#include <iostream>

extern int n; // declaration of a variable

class X; // (forward) declaration of a class

void foo(X x); // function declaration

class X
{
public:
        void bar()
        {
                std::cout << "X::bar()" << std::endl;
                ++n;
        }
}; // class definition

int n = 0; // definition of variable

void foo(X x)
{
        x.bar();
} // function definition

int main()
{
        X x;
        foo(x);
}

---

As you can see, I can use X and n before they are defined (but they are declared).
However, I cannot define foo() before I have defined X, because it uses a member function of X. If X is only declared, but not defined, the compiler doesn't know X::bar exists.

Quote:

---

Originally Posted by sgiri1981

I always thought that the stuff in header file (class name, its members function etc) is a declaration whereas the definitions are the details of those declarations that go in .cpp file. Is it incorrect to think of it this way?

sgiri

---

This is how I think of it:

Code:

---

// Declaration.
class Foo;

// Declaration.
class Foo
{
public:
    void Func();
};

// Definition.
void Foo::Func()
{
}

// Declaration and definition.
class Foo
{
public:
    void Func()
    {
    }
};

---

Quote:

---

Originally Posted by Mybowlcut

This is how I think of it:

Code:

---

// Declaration.
class Foo
{
public:
    void Func();
};

---

---

That's not entirely correct. You are defining the class Foo, but only declaring it's member function Func().

It's easy to check, by the way. You can have multiple declarations of the same thing, but only one definition (if we consider only one compilation unit, at least).

Quote:

---

Originally Posted by D_Drmmr

That's not entirely correct. You are defining the class Foo, but only declaring it's member function Func().

---

I think that it can go either way... it is a declaration because you're only declaring the functions (interface), but it is also a definition because you are listing data members (implementation). I prefer to think of it as a declaration though, because the defining (function behaviour and data initialisation) is generally done elsewhere (unless I'm using templates in which case I tend to define everything at the point of declaration).

Quote:

---

Originally Posted by D_Drmmr

It's easy to check, by the way. You can have multiple declarations of the same thing, but only one definition (if we consider only one compilation unit, at least).

---

Easy to check what? Multiple declarations of the same thing? You mean like multiple forward declarations?

Quote:

---

Originally Posted by Mybowlcut

I think that it can go either way... it is a declaration because you're only declaring the functions (interface), but it is also a definition because you are listing data members (implementation). I prefer to think of it as a declaration though, because the defining (function behaviour and data initialisation) is generally done elsewhere (unless I'm using templates in which case I tend to define everything at the point of declaration).

---

It is a class definition that contains a member function declaration. Because a class definition is also a class declaration, it is also a class declaration. If you think of it as a class declaration only, then it implies that you think that you cannot include the header that contains this class declaration and then instantiate a Foo object, because the Foo class has not yet been defined at that point.

Quote:

---

Originally Posted by Mybowlcut

Easy to check what? Multiple declarations of the same thing? You mean like multiple forward declarations?

---

I mean this is possible:

Code:

---

class foo;
class foo;

---

Whereas this is not:

Code:

---

class foo
{};
class foo
{};

---

Hence, the class is defined twice in the last code, whereas it is declared twice in the first code. That's what I meant with 'checking'; you can use the compiler to check your understanding.

I'm glad my topics generate some discussion. I had previously been interpreting it the same way Mybowlcut is, because, at a glance, that seemed to fit the way the words are used in other aspects of the language (functions, variables, structs, etc). However, I can completely understand why it's a function definition, thus also a function declaration.

What I decided to do about my situation is simple. For the code that I'm writing based off this book/source, I'm leaving the method definitions in the header file, but outside of the class definition. Makes me more comfortable, and seems cleaner to me. This way, you can quickly look through the class to see what's in it before looking at any method definitions.

Quote:

---

Originally Posted by laserlight

It is a class definition that contains a member function declaration.

---

Ok, fair enough.

Quote:

---

Originally Posted by laserlight

Because a class definition is also a class declaration, it is also a class definition.

---

Typo? Doesn't make sense to me though, even if I relate it to D_Drmmr's example; perhaps it's just the phrasing?

Quote:

---

Originally Posted by laserlight

If you think of it as a class declaration only, then it implies that you think that you cannot include the header that contains this class declaration and then instantiate a Foo object, because the Foo class has not yet been defined at that point.

---

I don't know enough about compilation etc. to really talk about stuff like this, but isn't the .cpp merged with the .h at compilation? E.g. the definition is always guaranteed to be complete by the time you include it (unless you have circular dependencies or haven't defined functions/statics/etc)? Hence making it a definition? I think I see what you're saying, though, and it does make sense. :thumb:

Quote:

---

Originally Posted by D_Drmmr

I mean this is possible:

Code:

---

class foo;
class foo;

---

Whereas this is not:

Code:

---

class foo
{};
class foo
{};

---

Hence, the class is defined twice in the last code, whereas it is declared twice in the first code. That's what I meant with 'checking'; you can use the compiler to check your understanding.

---

Nothing like a good code sample... I get it now haha.

Quote:

---

Originally Posted by Mybowlcut

Typo? Doesn't make sense to me though, even if I relate it to D_Drmmr's example; perhaps it's just the phrasing?

---

Typographical error: the latter "definition" should be "declaration".

Quote:

---

Originally Posted by Mybowlcut

I don't know enough about compilation etc. to really talk about stuff like this, but isn't the .cpp merged with the .h at compilation? E.g. the definition is always guaranteed to be complete by the time you include it (unless you have circular dependencies or haven't defined functions/statics/etc)? Hence making it a definition?

---

Well, that would be true if you were including the header in the source file that contains the member function definition. But what if you were including the header in another source file that contains code that is supposed to use objects of the class type?

Quote:

---

Originally Posted by laserlight

Well, that would be true if you were including the header in the source file that contains the member function definition. But what if you were including the header in another source file that contains code that is supposed to use objects of the class type?

---

I don't know haha. That's why I said I don't know much about it. :p

This has been a great thought provoking thread, with the kind of discussions not found in any book.

Anyway, my chain of thoughts led me to wonder whats the difference between the following

Code:

---

#include <iostream>


#include "/relative path given in make file/MyProject/someFile.h"

---

In the first case, I believe the compiler will look for the standard C libraries provided along with the compiler (??? not sure here). Thats because we are enclosing the includes in < >.
Does it matter if these libraries are static or dynamic? Also, is there a separate file for each such library, or does it depend on the compiler (i use GCC)

Regarding second case, if some header file is not found in the path where it is supposed to be, then the compiler will complain. If the definition of a class is not found, then the linker will complain.

thanks in advance,
sgiri


sgiri

Quote:

---

Originally Posted by sgiri1981

In the first case, I believe the compiler will look for the standard C libraries provided along with the compiler (??? not sure here). Thats because we are enclosing the includes in < >.

---

I think that the text of the C++ standard should be a good read here:

Quote:

---

A preprocessing directive of the form

Code:

---

# include <h-char-sequence> new-line

---

searches a sequence of implementation-defined places for a header identified uniquely by the specified sequence between the < and > delimiters, and causes the replacement of that directive by the entire contents of the header. How the places are specified or the header identified is implementation-defined.

---

Quote:

---

Originally Posted by sgiri1981

Does it matter if these libraries are static or dynamic?

---

This just concerns headers, so the type of linking is not relevant.

Quote:

---

Originally Posted by sgiri1981

Also, is there a separate file for each such library, or does it depend on the compiler (i use GCC)

---

For the standard headers, it depends on the compiler. In theory, there might not even be a file for the header.

Quote:

---

Originally Posted by sgiri1981

Regarding second case, if some header file is not found in the path where it is supposed to be, then the compiler will complain. If the definition of a class is not found, then the linker will complain.

---

Again, allow me to quote the standard:

Quote:

---

A preprocessing directive of the form

Code:

---

# include "q-char-sequence" new-line

---

causes the replacement of that directive by the entire contents of the source file identified by the specified sequence between the " delimiters. The named source file is searched for in an implementation-defined manner. If this search is not supported, or if the search fails, the directive is reprocessed as if it read

Code:

---

# include <h-char-sequence> new-line

---

with the identical contained sequence (including > characters, if any) from the original directive.

---

Quote:

---

Originally Posted by laserlight

I think that the text of the C++ standard should be a good read here:



This just concerns headers, so the type of linking is not relevant.


For the standard headers, it depends on the compiler. In theory, there might not even be a file for the header.


Again, allow me to quote the standard:

---

Thanks laserlight!
May I ask you the source of the c++ standard and is it readable for beginner/intermediate level programmer? (Google threw up some sites which were a little advanced for me)

sgiri

Quote:

---

Originally Posted by Raislin

What I decided to do about my situation is simple. For the code that I'm writing based off this book/source, I'm leaving the method definitions in the header file, but outside of the class definition. Makes me more comfortable, and seems cleaner to me. This way, you can quickly look through the class to see what's in it before looking at any method definitions.

---

Make sure you declare the function definitions as inline, else you run into linker errors when you include the header file in multiple cpp files.

Code:

---

class foo
{
        void bar();
};

inline void foo::bar()
{
        //...
}

---

Quote:

---

Originally Posted by D_Drmmr

Make sure you declare the function definitions as inline, else you run into linker errors when you include the header file in multiple cpp files.

---

Yeah, I already learned that the hard way. My intent was to try to keep from defining them as inline at all. But if I'm starting to understand correctly, that decision is made best by the compiler. I don't mind having a separate file for the definitions, though.

Quote:

---

Originally Posted by Raislin

What I decided to do about my situation is simple. For the code that I'm writing based off this book/source, I'm leaving the method definitions in the header file, but outside of the class definition. Makes me more comfortable, and seems cleaner to me. This way, you can quickly look through the class to see what's in it before looking at any method definitions.

---

That's not a problem for basic test/learning type programs, but don't get in habit for the long-term. When you start dealing with complex programs that involve dozens of classes, having everything in headers will mean that the slightest change in your source code requires huge amounts of recompiling.

That's a good thing to remember. I intend to keep the definitions out of the header from now on anyway.