return types

[falsepride]

okay im starting to learn c++. and its a strict language so everything needs to be defined as what type of value you it is right? like if i want to make a function to return a number id have to make it,

int myfunction() {
}

Is that right? If so what other types are there? im guessing var for variable, and viod returns nothing.

[Kernel_Killer]

int, char, double, float, void, etc, etc.

Don't forget your prototype at the beginning of the code as well.

[falsepride]

okay well i was kinda hoping for a full list. or a long list and what type of data it means.

[Valmont]

Buy or download a book. It's hard learning from a forum only. Start with int, double, char, std::string. Forget the rest. I have a reason for this. But that comes much later.

[falsepride]

what do the above mean though?
int - interger?
double - scientific notatoin?
char - character?
std::string - no idea
the :: is a operator for scope revolution, right? but what does that mean?

[sde]

Link

:: is the same as -> in php (classes)

you should really get a book at least for reference. web languages might let you slip by, but there is a lot more to c++.

[Valmont]

Originally Posted by sde

:: is the same as -> in php (classes)

Most likely not. :: is a scope resulution operator.
:: isn't chosen because of it looks by the way. Those who studied quantor mathematics should recognize this operator.
Anyway, it is the scope resolution operator, and we're going to have some fun with it. First the basics. Observe the code below and draw your own conclusions:

#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::endl;
using std::string;

//(auto generated) Optional function: depends on IDE. Remove if not needed.
void wait_for_enter();

//On-topic code below!

string whoAmI = "I am a global: usually a prime example of bad coding.";

namespace sde
{
  string whoAmI = "I am sde: the big boss!";
}

namespace Val
{
  string whoAmI = "I am Val: a slave of sde :)";
}

namespace falsepride
{
  string whoAmI = "I am falsepride: I'm looking at mumbo jumbo...";
}

int main(int argc, char *argv[])
{
  cout<< whoAmI <<endl; //the global
  cout<< sde::whoAmI <<endl; //sde
  cout<< Val::whoAmI <<endl; //Val
  cout<< falsepride::whoAmI <<endl; //falsepride
  
  cout<<endl;

  wait_for_enter();
  return 0;
}

//---------------------auto generated------------------------------

void wait_for_enter()
{
  cout << "press <enter> to continue...";
  // Reset failstate, just in case.
  cin.clear();
  string line;
  getline( cin, line);
}

Basically, multiple coders can work on the same code, without clashing with eachothers variables and all. Just define your stuff in your very own namespace.

And now we're going to find out whyusing namespace std; is actually bad.
Try to compile the code as it is below:

#include <ios>
#include <string>

using namespace std;

string dec;

int main()
{
  dec = "december";

  return 0;
}

Aha! This doesn't compile.
"dec" is already defined in the std namespace. Houston, we have a problem. Do we want the coder to use a different variable name for the month december then? Naah. We gotta solve this:

#include <ios>
#include <string>

using std::string;

string dec;

int main()
{
  dec = "december";

  return 0;
}

If you want to use the "dec" indentifier as well, then use it like this: std::dec
Now you're using the <ios> dec as well.
However, one shouldn't redefine typically standard keywords like I do below:
bad code below

#include <ios>
#include <string>
#include <iostream>

using std::string;
using std::endl;

string dec;
//Bad bad bad boy.
int cout;

int main()
{
  dec = "december";
  cout = 1;
  
  //Argh...
  std::cout<< cout <<endl;

  return 0;
}

This should be enough brain teasing to get you started. Good luck!

[falsepride]

okay the first example i get completely, when inside of a name space they are all local variables, and you access the local variables by doing namespace_name::variable_name. but what does

using std::cin;
using std::cout;
using std::endl;
using std::string;

do? i have ideas, but id rather be sure, then get into bad thinking

[Valmont]

So we want to prevent the usage of using namespace std; right?
The way to code is then:

std::cout<<"hi"<<std::endl;
std::string theString("I am a string");
std::cout<<theString<<std::endl;

But there are so many keywords and reserved items that typing std:: becomes tedious. Instead, use one time code like this:

#include <iostream>
#include <string>

using std::cout;
using std::endl;
using std::string;

And now we can use cout, endl and string without typing the scope resultion operator all the time in front of them.

Here is a sample.

#include <iostream>
#include <string>

using std::string;
using std::cout;
using std::endl;

namespace falsepride
{
   int theInt(5);
   string theString("Hello");
}

//From now on, we will use falsepride's variables!
using falsepride::theInt;
using falsepride::theString;

int main()
{
  cout<<theInt<<endl;
  cout<<theString<<endl;
  
  return 0;
}

There is a small problem now. Now the rest of your collegues aren't allowed to define their stuff with the same names that you used.
The neat way to do is this (and I will add my own little project in my own namespace):

#include <iostream>
#include <string>

using std::string;
using std::cout;
using std::endl;

//Each programmer his own workspace!

namespace falsepride
{
   int theInt(5);
   string theString("Hello");
}

namespace valmont
{
   int theInt(12);
   string theString("SPQR");
}



int main()
{
  //Use falspride's definitions.
  cout<<falsepride::theInt<<endl;
  cout<<falsepride::theString<<endl;
  
  //Use valmont's definitions.
  cout<<valmont::theInt<<endl;
  cout<<valmont::theString<<endl;
  
  return 0;
}

A last example. We both are going to define a simple output function. But there will also be a global version. Just read the comments in the code for details.

#include <iostream>
#include <string>

using std::string;
using std::cout;
using std::endl;

//The global version. This one is slightly safer and certainly
//faster for LOTS of shifting with HUGE amounts of text.
void print_the_stuff(const string& stuff)
{
  cout<<stuff<<endl;
}

//falsepride chooses the unsafe yet modern way.
namespace falsepride
{
   void print_the_stuff(string stuff)
   {
     cout<<stuff<<endl;
   }
}

//Val does it the unsafe and old fashioned way.
namespace valmont
{
   void print_the_stuff(char* stuff)
   {
     cout<<stuff<<endl;
   }
}

int main()
{
  //Use falspride's version.
  falsepride::print_the_stuff("This is from falsepride.");
  
  //Use valmont's version.
  valmont::print_the_stuff("This is from Valmont.");
  
  //Use global version.
  print_the_stuff("Global version here!");
  
  return 0;
}

Play with it. For more questions, just ask.

[falsepride]

so std is a namespace defined in iostream.h header file?

[sde]

ah nice work val .. i always thought of :: as accessing a member of a class, .. but i guess it's a lot more than that.

[Valmont]

Oh you *must* use the scope resolution operator to access members of a class. But not just ordinary members. STATIC members only.

But for normal accessing, we use also -> and . (dot).

Let's find out about statics now:

Rules:
- A decleration of static members in a class means NOT that it is defined.
It is only there for us humans to see that it is a static member. This is called "logical presence" instead of "physical presence".
- You must define the static member OUTSIDE the class, on a global level.
Usually, immediatly after the definition of the class is the place to do so.
- A static member WILL exist BEFORE any object (instance of a class) exists.
- If statics are not initialized, the standard dictates that the static will automatically initialized with the value "0". For std::string this means an empty string.
- All instances of a class will share the same static member.

Observe how I use the :: operator to define the static just outside the class.
A demonstration follows below:

#include <iostream>
#include <string>

using std::string;
using std::cout;
using std::endl;

class ClassWithAStatic
{
public:
  static string theString;
  inline string show_static()
  {
    return theString;
  }
};

//Must declare out of class!
string ClassWithAStatic::theString("I Live before all.");

int main()
{
  ClassWithAStatic a, b;
  cout<<a.show_static()<<endl;
  cout<<b.show_static()<<endl;
  
  //Lets redefine the static member. Notice that all objects adapt it's value.
  ClassWithAStatic::theString = "I am reborn for all.";
  cout<<a.show_static()<<endl;
  cout<<b.show_static()<<endl;
  
  return 0;
}

However, I didn't want to mention this for falsepride. This should come a week later if he studies seriously.

[Valmont]

Originally Posted by falsepride

so std is a namespace defined in iostream.h header file?

Very brave. I've asked you to draw your own conclusions and you did. That I appreciate!

The answer:
No. The otherway around:
iostream is defined within the namespace std;


namespace std
{
TONS OF SYSTEM STUFF IN HERE LIKE iostream, cmath, ios, fstream ETCETERA
}

But obviously this is devided systematically over a number of files. We call them header files.
That will come later.
A "namespace" is nothing else but a fancy name for grouping things.
This code is valid too, using {} to group things:

{ //Grouping starts here.
   {
      cout<<"hi"<<endl;
   }
}//Grouping ends here.

Useless it seems, but it is valid.
This is by the way a trick to avoid certain bugs with certain compilers. But don't you worry about that. Just demonstrating.

[Valmont]

And since I am toying with code, why not toying a bit more huh? But this time only for veterans and geeks. The rest of you better don't watch .

Question: is this valid code?

#include <iostream>

using std::cout;
using std::endl;

int main()
{
   cout<<"Hi all."<<endl;
}

I've warned you. Don't look if you can't bear it .
I am outta here. You guys have fun with this.

[falsepride]

does std stand for anything? maybe standard? i duno(knowing full names sometimes makes it easy for me to remember and to make references in my brain to understand what it does). and if you need to include iostream.h to use cout, im guessing that std is a name space contain your functions and what not, but only certian functions are in it depending on what header files youve included? There are hundreds upon hundreds of header files that came with borland, how do i know functions are in each?

And as for your code, its valid right?