differences between a c-function and a class method

[gustav04]

hi all


i have a question:

what is the difference between a c-function and an c++ class method
(both do exactly the same thing).

lets say, i have a function called print2std() and a class called CUtils
with a static method called print2std()

The first one can be called within a programm simply with print2std(),
but the second one must be called with CUtils:rint2std().

what are the differences ?
Or why use c++ programmers sometimes c-functions, too ?
Why don't they use classes with static methods instead?


Regards
gustav

 

[bachelor]

Int your case CUtils has not to be a class - usually it is a namespace
(for example you have std namespace, and sqrt(...) functions are placed
there).
---------------------------------
namespace std{
double sqrt(double d) { ... }
}
---------------------------------

If you write your own sqrt function, your function name will not
conflict with std::sqrt().
static methods are a bit more advanced - they can be private or
protected - you can hide them for some reason, so they cannot be used
from outside of the class.

 

[David Lindauer]

hi all

i have a question:

what is the difference between a c-function and an c++ class method
(both do exactly the same thing).

lets say, i have a function called print2std() and a class called CUtils
with a static method called print2std()

The first one can be called within a programm simply with print2std(),
but the second one must be called with CUtils:rint2std().

what are the differences ?
Or why use c++ programmers sometimes c-functions, too ?
Why don't they use classes with static methods instead?

The basic difference is that the static class method function can access
other static members of the class, whereas the function outside of a class
may not be able to depending on how the protection is set up.

You may want to use a generic function instead of a class member function if
for example you are writing something not dependent on a data structured
defined as a class, or if you are writing something that works with data
structures for several different classes.

David

 

[DHOLLINGSWORTH2]

hi all


i have a question:

what is the difference between a c-function and an c++ class method (both
do exactly the same thing).

lets say, i have a function called print2std() and a class called CUtils
with a static method called print2std()

The first one can be called within a programm simply with print2std(), but
the second one must be called with CUtils:rint2std().

what are the differences ?
Or why use c++ programmers sometimes c-functions, too ?
Why don't they use classes with static methods instead?


Regards
gustav

IF your C procedure operates on "Class data" then you've messed the whole ++
thing. It's a matter of Object Orientation.
- a C procedure takes up less space than C++;
- a C procedure takes up more Time than C++, unless you are passing a lot of
references to the data being operated on.
- if data flows out of an object and not back in, I'd say use C when you
can. If the data flows back into an object, stick to C++.
- the matter is one of protection, and believe me, you will save on aspirin
debugging large projects.
- objects of the same class share methods, but use a seperate base pointer
to this objects data. a C procedure needs to pass in ALL of the pointers to
data.
- a C procedure doesn't care whos data its messing with, or if the data is
valid.

 

[Howard]

IF your C procedure operates on "Class data" then you've messed the whole
++ thing. It's a matter of Object Orientation.
- a C procedure takes up less space than C++;
- a C procedure takes up more Time than C++, unless you are passing a lot
of references to the data being operated on.
- if data flows out of an object and not back in, I'd say use C when you
can. If the data flows back into an object, stick to C++.
- the matter is one of protection, and believe me, you will save on
aspirin debugging large projects.
- objects of the same class share methods, but use a seperate base pointer
to this objects data. a C procedure needs to pass in ALL of the pointers
to data.
- a C procedure doesn't care whos data its messing with, or if the data is
valid.

What??????

Where the heck did you get this information from?

First off, there are no "C" procedures versus "C++" procedures. If you're
compiling in C++, it's ALL C++! The difference is between member functions
and non-member functions, not C and C++. I understand that C++ has added
the use of member functions, but that doesn't make non-member function "C
procedures".

What makes you say that a non-member function takes up less space? Are you
referring to the parameters that get pushed when the function gets called?
In that case, there is indeed (at least conceptually, if not always in fact)
space reserved for the "this" pointer when making the call, but the itself
function is no larger. Also, static member functions, as in the OP's
example, don't use a "this" pointer, and so do not even take up that extra
space when called.

Next (referring to objects and the use of C or C++ based on data flow
direction), what makes you prefer using a non-member function for reading
data but a member function for writing data? That's very inconsistent.
Perhaps you're referring to the somewhat common practice of using a struct
and non-member functions for common tasks that don't require any special
data handling, such as a Point struct, which only has x and y members and is
used simply as a data holder for passing coordinates to functions like Move
and MoveTo? Regardless, it's not possible to only pass data ot of an
object. The data HAS to go in, somehow!

I have no idea what you're trying to say about non-member requiring passing
in ALL of the pointers to the data! You can certainly pass a pointer to a
struct or class to a non-member function. In member funcitons, if you're
operating on the object itself, then you don't have to *explicitly* pass the
object instance (unless you're calling a static member function). But it
*does* get passed to the function, as a kind of "hidden" parameter.

Finally, I don't see what the validity of the data has to do with anything,
regardless of whether you're referring to a member or non-member function.

To the OP:

I'd disregard the above posting altogether, if I were you.

Static member functions are indeed quite similar to non-member functions, in
that no "this" pointer exists, so there is no reference to a "current"
object. But you *can* access static member data or other static member
functions directly from a static member function, so they're not exactly the
same.

As for *why* use non-member functions, the most common reason, I suppose, is
when the function does not need to refer to an object. Consider the sin()
function. It takes an angle in radians and returns the sine for that angle.
No object is needed, and it would be more trouble to create an object just
to be able to call its sin function, wouldn't it?

There are many other common functions, often called "global" functions, that
act as utlities (scanf, sprintf, atoi, etc.) which don't require objects.
You should design your own code in a manner that is safe, consistent,
logical, and maintainable. And to help do that, I'd recommend some good
books, such as Scott Meyer's two "Effective C+" and More Effective C++"
books, and Stroustrup's "The C++ Programming Language".

-Howard

 

[Howard]

[some typo corrections...]

space reserved for the "this" pointer when making the call, but the itself
function is no larger. Also, static member functions, as in the OP's

should have read: "but the function itself is no larger"

and MoveTo? Regardless, it's not possible to only pass data ot of an
object. The data HAS to go in, somehow!

should have read: "not possible to only pass data OUT of an object"

struct or class to a non-member function. In member funcitons, if you're
"functions"

books, such as Scott Meyer's two "Effective C+" and More Effective C++"

his name is Meyers, so that should be "Meyers'", not "Meyer's".

-Howard

 

[Jerry Coffin]

gustav04 wrote:

[ ... ]

lets say, i have a function called print2std() and a class called
CUtils with a static method called print2std()

The first one can be called within a programm simply with
print2std(), but the second one must be called with
CUtils:rint2std().

what are the differences ?
Or why use c++ programmers sometimes c-functions, too ?
Why don't they use classes with static methods instead?

A static member function and a non-member function are generally
equivalent in terms of code produced, calling convention, etc.

As to when/why you'd use a non-member function, I'd turn the question
around: when/why SHOULD you use a static member function instead of a
non-member function? Generally speaking, you should do so when it makes
sense to -- when the function is logically related to one (and only
one) class.

Even that, however, is really a little too broad -- there are times
that a function clearly IS related specifically to one particular
class, and it still can't be a member function (static or otherwise).
One obvious case would be when you're overloading an operator. For
example, consider something like:

class X {
// ...
};

std:stream &operator<<(std:stream &os, X const &x);

This might be a _friend_ of the class, but if you attempt to make it a
member of the class, it simply won't work. To work as a member
function, it would have to be a member of class ostream -- but it would
be impractical to modify class ostream every time we want to support
output for a new type. Worse, making them members of ostream would give
them access to the internals of ostream, and we really don't want that
at all.

The same is true in quite a few other cases of operator overloading.
Consider something like:

class rational {
int num, denom;
public:
rational(long numer=0, long denom=1);
// rational operator+(rational const &);
};

rational operator+(rational const &, rational const &);

Now, if we used the member operator+, it would only work when its left
operand was already a rational number -- something like y=x+2 would
work, but y=2+x would not. Since people normally expect the two to be
equivalent, this is a bad thing.

The cure is to use the non-member overload of operator+. This can do a
conversion on the left operand, so it comes out as something like:

y=operator+(rational(2), x);

or:

y.operator=(operator+(rational(2), x));

and life is good. Of course, the same is also true when dealing with
most other operators as well -- though a few such as assignment must be
member functions, since it doesn't make much sense to create a
temporary object to assign to.