A few beginner's questions

I hail from C# and C++ is confusing me a lot.

1) I just got an error for putting the visibility identifier before the name of a method (at least I think that was the reason), so it's absolutely mandatory I use private: or public: and then put the methods and attributes after these declarations?
And private is standard, so I don't need to write it or?

2) I got an error for defining a method inside the class it belongs to (again, I think so), WTF?
How can you achieve data encapsulation when half the code of a class isn't part of it but defined globally?
In all the examples I've seen so far, it was done this way, is that mandatory or just optional?
And if it's mandatory, how do I write libraries and encapsulate classes in them, where am I supposed to define the methods, so that I can later just call them without any extra code?

3) Is there any kind of general exception I can catch, that at least tells me some vague info about what happened?
I only found specific exceptions and adding the throw(...) statement to add in a function's name, but this won't tell me jack about what happened.

4) The constructor of a class is called without using the new statement?
What do I use the new statement for? Only for arrays?
And that means just declaring a variable of a class (and structure/Union,too?) will allocate the necessary memory?

5) How do I convert from numbers/Boolean into strings and back, is there anything resembling Parse/TryParse functions from C#?
From what I've read, I can only think of outputting a number/bool into a stringstream and then inputting that back into a string. For the other way around I can only think inputting the string into the number/bool from a stringstream and then maybe using a nested try-catch block to check if it worked.

Thanks in advance.

1) Yes, you use public: and list everything
2) You shouldn't get an error. You can define the method in a normal class. There are some issues though. Does that method (function) uses objects from another class? If so you have to check forward declaration and stuff which don't exist (hopefully) in C#. In any case it won't be defined globally, you would probably need the :: scope symbol. Like class::method. Post certain code for more clarifications.
4) In C++ this is an object:

Code:

---

object O;

---

the same way you declare a variable. You can use a constructor like:

Code:

---

object O(a,  b);

---

the new keyword dynamically allocates memory.
In C# this is a reference and not an object:

Code:

---

object O;

---

the equivalent thing in C++ is this for a reference:

Code:

---

object& O; //even though you would get an initialization error

---

Code:

---

object& O = new Object(a,b);

---

So, the new is dynamically allocation, without the new is statical allocation. In any way you will have allocated memory.
5) There should be certain functions that do that. I ll search and post some

A C++ way is:

Code:

---

std::stringstream ss;
int t = 123;
ss << t;
std::string str = ss.str();

---

The opposite:

Code:

---

std::istringstream ss;
std::string str = "2443"
int t;
ss >> t;

---

You can also use sprintf(), atoi() and other functions. Google and you will find many results.

For example I find this:

Code:

---

#include <boost/lexical_cast.hpp>
#include <string>

try
{
    std::string text = "152";
    int number = boost::lexical_cast< int >( text );
}
catch( const boost::bad_lexical_cast & )
{
    //unable to convert
}

---

1) Those keywords apply to all methods and variables listed below them (unless you use a different keyword). In classes the default visibility is private, so indeed you can list your private members before the public ones without needing the private keyword.

2) You may need to post a concrete example.

3) You can catch std::exception& and see what the what() method of it returns. All standard library exceptions are derived from std::exception and you should also use these (or derive your exception types from them).

E.g

Code:

---

#include <iostream>
#include <string>
#include <exception>
#include <boost/lexical_cast.hpp>

int main()
{
    std::string s("10.2");
    try {
        int i = boost::lexical_cast<int>(s);
    }
    catch (std::exception& e) {
        std::cout << e.what() << '\n';
    }
}

---

Even though lexical_cast is not part of the standard but of the boost library, the bad_lexical_cast exception is derived from std::exception, so it can be still caught like that.

boost::lexical_cast is also probably the best way to convert between other types and strings.

4) In C++ there are stack (automatic) objects and heap (dynamically allocated) objects. The first ones are deallocated automatically when they go out of scope, the second ones remain until they are deallocated with delete. Both object creation methods have their own uses, but unless you have pressing reasons you should prefer automatic objects (without the new keyword).

5) One way is to download and use boost. But it can also be done with stringstream (which boost::lexical_cast uses internally). However, streams don't throw exceptions, so you should check the fail bits of the stream after the conversion (and perhaps whether the entire string was converted) to know if it succeeded.

To make my point more clear about your 4) questions.
In C# ALL objects go in the heap. They are dynamically allocated.
In C++ you choose where objects go. If you declare them "normally" the go in the stack. If you use the new keyword the go in the heap (dynamically allocated). C++ does things as they would normally be done in C.

In C# you have the option of statically allocating or dynamically allocating when you use value types, like int, uint, char etc etc not reference types, like objects.

This might help: http://www.c-sharpcorner.com/UploadF...5-413b6d348b91

Thanks a lot!

I had read something about C++ objects not being passed by reference but by value, though I didn't know all of the data was normally on the stack.

Quote:

---

If you use the new keyword the go in the heap (dynamically allocated).

---

I only get errors when using it.

I tried something like

Code:

---

Object o = new Object();

---

As you would in C# and it doesn't work. How would be the correct syntax?

And is it best to only use pointers to objects (which would mimic C#) so that you can't make the mistake of passing them by value?

As for defining methods inside their class, my wording was bad. I didn't mean globally but rather that the method body is defined in the namespace, yet outside the class itself:

Code:

---

using namespace std;

class something
{
public:
        int add(int, int);
        int multiply(int, int);
};

int something::add(int a, int b)
{
        return a+b;
}

int something::multiply(int x, int y)
{
        return x*y;
}

void main()
{
. . .

---

What I would want to do (and I'm used to in C#) is to put all code that is part of a class between the starting and ending brackets:

Code:

---

class something
{
public:
        int add(int a, int b)
        {
                return a+b;
        }

        int multiply(int x, int y)
        {
                return x*y;
        }
};

---

Also, how do I make static methods (and classes)?
I tried around and just get more and more errors.

Quote:

---

Originally Posted by Megidolaon

As you would in C# and it doesn't work. How would be the correct syntax?

---

new Object() gives you a pointer to an Object object that is value-initialised. As such, you would write:

Code:

---

Object* o = new Object();

---

You also need to use delete when you are done with o, e.g.,

Code:

---

delete o;

---

Quote:

---

Originally Posted by Megidolaon

And is it best to only use pointers to objects (which would mimic C#) so that you can't make the mistake of passing them by value?

---

No. To avoid passing them by value, make the parameters of the relevant functions take the objects by (const) reference. Of course, in some situations you actually want to pass objects by value, e.g., you want to work on a copy anyway.

Quote:

---

Originally Posted by Megidolaon

What I would want to do (and I'm used to in C#) is to put all code that is part of a class between the starting and ending brackets:

---

You can define member functions inline in the class definition if you wish, so the error is probably a typographical error or something else.

Quote:

---

Originally Posted by Megidolaon

Also, how do I make static methods (and classes)?

---

What did you try? There is no such thing as a static class in C++, as far as I know.

Code:

---

Object *o = new Object();

---

As to your class member function definitions, they are no more global than if you put them within the class declaration itself. Functions within the class declaration itself default to inline, but otherwise it's just a matter of "where does it make sense to put this function". They are no more available to anyone outside of the class in either case. Obviously, if you have large functions (10-100 lines), then the function is much better off outside of the class itself, since the class definition gets very cluttered up if you have the lots of code inside it.

--
Mats

And at last: http://cpwiki.sf.net/void_main
You're picking up bad habits, because void main is undefined. You shouldn't use it.

Since you seem new to C++, I should give you an advice to actually learn about pointers. You can't avoid them.
You'll also want to learn the trivial things about syntax, T* vs T * for one (laserlight uses T*, mats uses T *, both are right, and none are wrong): http://www.research.att.com/~bs/bs_faq2.html#whitespace

Quote:

---

Originally Posted by Elysia

And at last: http://cpwiki.sf.net/void_main
You're picking up bad habits, because void main is undefined. You shouldn't use it.

Since you seem new to C++, I should give you an advice to actually learn about pointers. You can't avoid them.
You'll also want to learn the trivial things about syntax, T* vs T * for one (laserlight uses T*, mats uses T *, both are right, and none are wrong): http://www.research.att.com/~bs/bs_faq2.html#whitespace

---

*Bookmarks*

And it was written, let no one ever forget the post known only as 799191. Which is similar to an old phone number of mine, so I probably will remember it easily :)

Thanks once more.

Quote:

---

You can define member functions inline in the class definition if you wish, so the error is probably a typographical error or something else.

---

I see, does anyone have a link where I can look up the correct syntax, because all tutorials I've found define the methods outside the class.

Quote:

---

No. To avoid passing them by value, make the parameters of the relevant functions take the objects by (const) reference. Of course, in some situations you actually want to pass objects by value, e.g., you want to work on a copy anyway.

---

Do I need an extra variable if I have a normal object and a function that only takes a pointer to such an object?

Quote:

---

What did you try? There is no such thing as a static class in C++, as far as I know.

---

I almost finished an rpg battle system in C# and for that I'd have actions like attack or use item as classes.
Now since they are always the same, regardless of which character/enemy uses them, they should be static so they don't waste unnecessary memory.

--Do this:

Code:

---

class A
{
public:
  int a;
  void show(int i) {std::cout << a;}
};

---

it compiles normally. As this one:

Code:

---

class A
{
public:
  int a:
  void show(int i);
};
void A::show(int i) {std::cout << a;}

---

I ll make a guess which MAYBE is correct (don't have g++ at the moment to test it).

Code:

---

class A
{
public:
  void doNothing(B par) {;}
};
class B
{
  int b;
};

---

The above might not work, because B was declared below A. So you might need this:

Code:

---

class A
{
public:
  void doNothing();
};
class B
{
  int b;
};
void A::doNothing() {B b();}

---

which I believe should work. In C# you don't have to worry about these thinks

--No, you don't need an extra variable. I don't fully understand what you mean. In C++ you can do MORE than C# when it comes to passing objects to methods. You can do all the below:

Code:

---

void add(obj o);
void add(obj& o);
void add(obj* o);

---

Now, in the first two you will pass an object normally, as in C#. Like:

Code:

---

obj o();
add(o);

---

in the third method you need to pass a pointer. Like:

Code:

---

obj o();
obj* ptr_o = &o;
add(ptr_o); //or just add(&o);

---

The first two methods differ only on the HOW the object is passed. Everything else is as in C#. The C# way is the second, passing the object by reference. The first makes a copy of the object. It is like passing an object, making a copy and using the copy.

--Well, you can make a method static. Like:

Code:

---

class attack
{
public:
  int damage;
  static use() {...}
};
...
int main() {
character ch1(), ch2();
attack.use(ch1, ch2);

---

Quote:

---

Originally Posted by C_ntua

The above might not work, because B was declared below A.

---

That's true, but one can just move the definition of B before the definition of A.

Quote:

---

Originally Posted by C_ntua

Now, in the first two you will pass an object normally, as in C#. Like:

---

fyi, this declares a function named o that takes no arguments and returns and returns an obj:

Code:

---

obj o();

---

Quote:

---

Originally Posted by C_ntua

I ll make a guess which MAYBE is correct (don't have g++ at the moment to test it).

Code:

---

class A
{
public:
  void doNothing(B par) {;}
};
class B
{
  int b;
};

---

The above might not work, because B was declared below A. So you might need this:

---

This is incorrect, because it takes a B by-value and B is not yet defined. It doesn't even work with a forward declaration.
You need to take it by pointer or reference with a forward declaration or define B before A.

Quote:

---

Code:

---

class A
{
public:
  void doNothing();
};
class B
{
  int b;
};
void A::doNothing() {B b();}

---

which I believe should work. In C# you don't have to worry about these thinks

---

And as laserlight pointers out, don't use () on objects with a constructor that takes no arguments. It's a declaration.
The correct code is

Code:

---

B b;

---

Quote:

---

--Well, you can make a method static. Like:

Code:

---

class attack
{
public:
  int damage;
  static use() {...}
};
...
int main() {
character ch1(), ch2();
attack.use(ch1, ch2);

---

---

This is also incorrect. The correct syntax to call a static method is:
attack::use

Really, sorry for my mistakes :S
Kind of answered quick...

Just to mention though that maybe you could have:

Code:

---

class A
{
public:
  void doNothing(B par) {;}
};
class B
{
  int b;
  A a;
};

---

so you know.... I believe that was the cause that the function HAD to be outside

You can't have that because
a) A references B with pass-by-value which is defined later.
b) B relies on A, which creates a circular reference.

Quote:

---

Originally Posted by Elysia

You can't have that because
a) A references B with pass-by-value which is defined later.
b) B relies on A, which creates a circular reference.

---

But A does not store an object of B, so the definition of B is only needed when defining A::doNothing. C_ntua's point is that that is one example where defining the member function inline will not work, but defining it outside of the class definition will work, assuming that a forward declaration of B is used before defining A. Admittedly, I did not consider this possibility.

This actually works then? Standard is OK with it & all that?

Quote:

---

Originally Posted by Elysia

This actually works then? Standard is OK with it & all that?

---

Yes. "A class type T must be complete if: (...) a function with a return type or argument type of type T is defined or called" (C++03 section 3.2). Thus, if a function that takes an argument of class type B is only declared, the class B need not be defined at that point.

A class type T must be complete if: (...) a function with a return type or argument type of type T is defined (return type only?) or called.
That line seem ambiguous with its intent.

Quote:

---

Originally Posted by Elysia

A class type T must be complete if: (...) a function with a return type or argument type of type T is defined (return type only?) or called.
That line seem ambiguous with its intent.

---

Not the way I read it:
If you either DEFINE a function that returns T or has a T argument, T needs to be complete.
OR
If you call a function that returns T or has a T argument, T needs to be complete.

It's just shorter to write it in the way the spec does it.

--
Mats

How is it ambiguous?

Because it seems to contradict what you say.
I read it as mats do. If a function uses a parameter of type T, then T must be complete.
Of course, I interpret define as defining it in the class definition, and not as in the implementation.

[QUOTE=Elysia;799547Of course, I interpret define as defining it in the class definition, and not as in the implementation.[/QUOTE]

That's where you are going wrong. Definition of the function is what the original text refers to, and that's my intention too.

Edit: Essentially, the code-generator needs to know how large the type is, when generating the code. Since most compilers don't read all of the code and only when it has all the code in a huge tree/list of some sort, start to generate code. Instead, each function, as it's defined, becomes some sort of "pseudo-machine code", which is then used to produce the actual machine code in some way. At this stage of "pseudo-machine code" generation, the size of all data types used by the function needs to be known.

--
Mats

Quote:

---

Originally Posted by Elysia

Of course, I interpret define as defining it in the class definition, and not as in the implementation.

---

To implement a function is to define it.

This is just confusing.
A class declaration is also a class definition.
And a class implementation is also a class definition.
Which is which here?

Quote:

---

Originally Posted by Elysia

This is just confusing.
A class declaration is also a class definition.
And a class implementation is also a class definition.
Which is which here?

---

But we are not talking about classes, but functions. And by the way, I think a class declaration is

Code:

---

class X;

---

, whilst a class defintion is

Code:

---

class X { ... stuff ... };

---

- declaration tells the compiler "there's a class called X", whilst the defintion tells the compiler what is INSIDE the class (member functions and member variables).

--
Mats

I think I see where the confusion stems from... Why couldn't they just make it the same for classes and functions? Silly standard-izers...

Quote:

---

Originally Posted by Elysia

I think I see where the confusion stems from... Why couldn't they just make it the same for classes and functions? Silly standard-izers...

---

But IT IS the same for classes and functions. The function declaration is a prototype - it tells the compiler "there's some function, and it takes some parameters", but nothing about what the function actually does. A function definition, like it's class counterpart, defines what is in the function (what it does).

--
Mats

Quote:

---

Originally Posted by Elysia

A class declaration is also a class definition.
And a class implementation is also a class definition.
Which is which here?

---

No, a class definition is a class declaration, but class declaration is not necessarily a class definition (e.g., a forward declaration is not a definition).

The implementation of a class is generally considered to be the implementation of its member functions (and other related functions, like friend functions, I suppose). A function definition is the implementation of that function. A class definition contains the declarations, not necessarily definitions, of its member functions, but the member functions may also be defined inline in the class definition.

Quote:

---

Originally Posted by matsp

But IT IS the same for classes and functions. The function declaration is a prototype - it tells the compiler "there's some function, and it takes some parameters", but nothing about what the function actually does. A function definition, like it's class counterpart, defines what is in the function (what it does).

--
Mats

---

But it's not the same...

Code:

---

int foo(int x);

---

I would call this a declaration, never a definition.
Similarly,

Code:

---

class foo { int foo_(int x); };

---

I would call this a class definition, unlike a declaration, which is obviously should be.

Code:

---

int foo(int x) {}

---

I would call this the function definition, never the function implementation.
Similarly,

Code:

---

int foo::foo_(int x) {}

---

I would call this an implementation, not a definition.

This is exactly where the confusion arises from.

So you have the declaration right, you just have to not stop. Just as the name itself is a declaration

Code:

---

int foo(int x); //function declaration

---

so is the name itself a declaration.

Code:

---

class Foo; //class declaration

---

Quote:

---

This is also incorrect. The correct syntax to call a static method is:
attack::use

---

I see and why do I need the ' :: ' operator?
When do I need this and when do I need the ' . ' operator?

Quote:

---

But A does not store an object of B, so the definition of B is only needed when defining A::doNothing. C_ntua's point is that that is one example where defining the member function inline will not work, but defining it outside of the class definition will work, assuming that a forward declaration of B is used before defining A. Admittedly, I did not consider this possibility.

---

I just tested it, it won't work.
If I don't declare class B above class A, I can't have a method in class A that uses class B. Even if I only declare the method in the class and define the body of the method below both classes, I get an error.
This is pretty tricky and will probably cause me headaches in the future.

And when creating a library, I'd just put the definitions of these methods below the class, while still in the same namespace?

As for the methods taking references to an object, I forgot that you can just add * and & to a variable call.
In this case, I'd make a method which takes a memory address of an object and pass that to the method, like this?

Code:

---

void Test(Object& obj)
{
    // Do Stuff
}

. . .

Object obj;

Test(&obj);

. . .

---

attack::use() means "call the member function use in CLASS attack". If you instead have attack.use() it means "call the member function use in the OBJECT attack".

A static member function is one that can be used without actually having an object of that class. It is a way to have functions that doesn't actually work on an object, but still belongs to the class in some way.

--
Mats

Quote:

---

Originally Posted by Megidolaon

Code:

---

void Test(Object& obj)
{
    // Do Stuff
}

. . .

Object obj;

Test(&obj);

. . .

---

---

It is...

Code:

---

void Test(Object& obj)
{
    // Do Stuff
}

Object obj;
Test(obj);

---

...or...

Code:

---

void Test(Object* obj)
{
    // Do Stuff
}

Object obj;
Test(&obj);

---