Computer Science Canada

A Start on C++ Some First Programs/Questions
Author:  [Gandalf] [ Sun Jun 26, 2005 4:30 pm ]
Post subject:  A Start on C++ Some First Programs/Questions
Well, I have decided that my lofty goal for the summer is to learn C/C++ and VB.NET. Well, I'm hoping to get at least a basic knowledge of one of them, so I'm starting with C++ (I've already tried C). I will post some of the programs I make and questions I have over here till I give up (which will hopefully not happen). If I can't do C++ then I'll fall back to C, and if not that then I'll fall back to either VB.NET or Ruby.

Well, alright, I think I have an alright understanding of cout and cin, and now I'm going into classes and objects. Then I will go to constructors/deconstructors, multiple objects of the same class, private members and friend functions, inheritance, virtual funtions, and pure virtual functions, then file objects and by then we'll see... If there are any tutorials you suggest on this site or on the internet then please suggest them since I need all the help I can get!

I was looking at inline assembly, and heck - it doesn't seem too hard. Once you get past that barrier then inline machine code doesn't seem all that bad either. But then again, that's just me and my insane first impressions.

Ok, I'll post some of my code when I reinstall my editor/compiler, but first I have a simple newb question.

Can you declare the value of a variable inside a class in C++? I see how it's not neccessary, but I'm just not sure if its possible.

Oh, and if you know of any good reference guides to C/C++ then I would be really happy too Razz .

*EDIT* Oh, and is it wise to use some C libraries while coding in C++? Or should you just use pure C++? Are some C libraries also considered C++ ones?


*NOTE TO SELF*
g++ name.cpp -o name.exe
gcc name.c -o name.exe
gcj name.java -o name.exe?
Author:  Cinjection [ Sun Jun 26, 2005 4:40 pm ]
Post subject:  Re: A Start on C++ Some First Programs/Questions
[Gandalf] wrote:

Can you declare the value of a variable inside a class in C++? I see how it's not neccessary, but I'm just not sure if its possible.

no, but that's what constructers are for.
[Gandalf] wrote:

Oh, and if you know of any good reference guides to C/C++ then I would be really happy too Razz .

www.cprogramming.com
[Gandalf] wrote:

*EDIT* Oh, and is it wise to use some C libraries while coding in C++? Or should you just use pure C++? Are some C libraries also considered C++ ones?

You can, but you can turn C libs into C++ libs by adding a c infornt and getting rid of the .h. So
code:

#include <time.h> //c style
//becomes
#include <ctime> //c++ style

That won't always work but in most cases it will. Need more help , just ask.
Author:  [Gandalf] [ Sun Jun 26, 2005 4:58 pm ]
Post subject: 
Thanks.
What compiler/editor should I use? Embarassed

I had a good one for C, but it doesn't work with C++. Do you know of a good, easy to use editor with a built in compiler? Free, might I add.

*EDIT* Oh man, I forgot so much, even about C. I took a basic "hello world" program just to test my C and it doesn't show hello world when compiled Confused.
c:
include <stdio.h>

int main()
{
   puts("Hello world");
   return 0;
}


It just says return code, execution time, and location of program.
Author:  1of42 [ Sun Jun 26, 2005 5:18 pm ]
Post subject: 
http://www.bloodshed.net/devcpp.html

Dev-C++ is a great IDE.
Author:  Cinjection [ Sun Jun 26, 2005 5:19 pm ]
Post subject: 
I use MVC++. But you have to pay to get that one. If you want a good free compiler you can use Dev C++(googleafy)(<--crazy me making new words).
Author:  Cinjection [ Sun Jun 26, 2005 5:22 pm ]
Post subject: 
Oh and here's Hello World in C++:
code:

#include <iostream>
using namespace std;

int main(){

cout<<"Hello World!"<<endl;

fflush(stdin); //flushes the input buffer
cin.get(); //pauses program
return 0;

}
Author:  [Gandalf] [ Sun Jun 26, 2005 5:45 pm ]
Post subject: 
Thanks!

Oh, and for Hello world, couldn't you just use this:

c++:
#include <iostream.h>
int main()
{
  cout<<"Hello World";
  return 0;
}


or wtd's way:
c++:
#include <iostream>

int main()
{
   std::cout << "Hello world" << std::endl;
   return 0;
}


I'm installing it right now.
Author:  Cinjection [ Sun Jun 26, 2005 5:49 pm ]
Post subject: 
Well ANSI standard says not to include the .h. You also need cin.get() to pause the program or else it will instently close. fflush() was thrown in there for good practice.
Author:  [Gandalf] [ Sun Jun 26, 2005 6:08 pm ]
Post subject: 
I see, thanks for the explanation.

Tell me what the problem is with this:
c++:
#include <iostream>

// Getting user input

main()
{
    float value;

    cout << "Input a number: ";
    cin >> value;
    cout << "The value is: " << value << "\n";
    return 0;

}

It says that cout and cin have not been declared Sad.

*EDIT* I found the problem, you DO have to have the .h after iostream, at least in my case.
Author:  wtd [ Sun Jun 26, 2005 6:13 pm ]
Post subject: 
Cinjection wrote:
Well ANSI standard says not to include the .h. You also need cin.get() to pause the program or else it will instently close. fflush() was thrown in there for good practice.


"fflush" and "stdin" are C, not C++, and is therefore extremely bad practice. Especially when you mix the two. They are different languages. Treat them as such.

Instead use the std::ostream class' "flush" member function. std::cout is an instance of the std::ostream class.

code:
std::cout.flush();


Flushing a buffer ensures that what is in it is actually output. For instance, on some systems with some compilers, nothing will be output until the end of the line, so if I were to ask for a person's name and get input on the same line, say with:

code:
std::string name;

std::cout << "Enter your name: ";
std::cin >> name;
std::cout << "Hello, " << name << "!" << std::endl;


What I would see on the screen would look like the following, assuming the name I entered was "wtd".

code:
wtd
Enter your name: Hello, wtd!


Flushing the std::cout buffer after prompting for the name ensures this won't happen.

code:
std::string name;

std::cout << "Enter your name: ";
std::cout.flush();
std::cin >> name;
std::cout << "Hello, " << name << "!" << std::endl;
Author:  md [ Sun Jun 26, 2005 6:33 pm ]
Post subject: 
[Gandalf] wrote:
I see, thanks for the explanation.

Tell me what the problem is with this:
c++:
#include <iostream>

// Getting user input

main()
{
    float value;

    cout << "Input a number: ";
    cin >> value;
    cout << "The value is: " << value << "\n";
    return 0;

}

It says that cout and cin have not been declared Sad.

*EDIT* I found the problem, you DO have to have the .h after iostream, at least in my case.


I think if you add the .h the file puts everything into the global namespace; whereas without the .h it's just in "std::". Of course I could be completely wrong Razz

What IDE/compiler did you chose?
Author:  wtd [ Sun Jun 26, 2005 6:35 pm ]
Post subject: 
You should not by any means install Dev-C++. It's a buggy product, and makes the whole process far more complex than it need be.

Instead, install GCC directly via MinGW (MInimalist GNU for Windows).

You will then need to edit your PATH environment variable to have command-line access to the GNU C++ compiler.

http://vlaurie.com/computers2/Articles/environment.htm
Author:  [Gandalf] [ Sun Jun 26, 2005 6:39 pm ]
Post subject: 
Dang, and it was a 50mb install.

Well, for the moment what's wrong with this? It doesn't output the answer.
c++:
#include <iostream.h>

// Getting user input

main()
{
    int x1, y1, x2, y2;  // A value the user inputs
    int slope;

    cout << "Input the first x coordinate: ";
    cin >> x1;
    cout << "Input the first y coordinate: ";
    cin >> y1;
    cout << "Input the second x coordinate: ";
    cin >> x2;
    cout << "Input the second y coordinate: ";
    cin >> y2;
    slope = (y2 - y1) / (x2 - x1);
    cout << "The slope is: " << slope << ".\n";
    cin.get();
}


Oh, and this is the Hello World program Dev-C++ gives:
code:
#include <iostream>

using namespace std;

int main (int argc, char *argv[])
{
  cout << "Hello World!" << endl;
  cout << "Press ENTER to continue..." << endl;
  cin.get();
  return 0;
}


Right now I'm using Dev-C++, but I will probably switch to what wtd said, if I can get it to work.
Author:  wtd [ Sun Jun 26, 2005 7:07 pm ]
Post subject: 
[Gandalf] wrote:
Dang, and it was a 50mb install.


It's a good lesson to learn early.

[Gandalf] wrote:
Well, for the moment what's wrong with this?


Several things. Let's take a look. Smile

c++:
#include <iostream.h>


"iostream.h" is deprecated. Whgile most compilers still do support it, there's no guarantee they will.

Use "iostream" instead.

c++:
// Getting user input


Useless comment.

c++:
main()


"main" should return "int".

c++:
{
    int x1, y1, x2, y2;  // A value the user inputs
    int slope;


You're mixing styles and using extraneous comments. I can gather from the following code that the user inputs values which get stored in those variables.

If you're going to declare more than one variable in one statement, there's no point in putting the declaration of slope in its own statement. You can still have it on a separate line.

However, you also don't need to declare slope here. You can declare it when you initialize it. C++ does not require declarations at the top of a function.

c++:
    cout << "Input the first x coordinate: ";
    cin >> x1;
    cout << "Input the first y coordinate: ";
    cin >> y1;
    cout << "Input the second x coordinate: ";
    cin >> x2;
    cout << "Input the second y coordinate: ";
    cin >> y2;


Nowhere have you specified that cout or cin have been brought into your namespace, from the std namespace where they dwell.

c++:
    std::cout << "Input the first x coordinate: ";
    std::cin >> x1;
    std::cout << "Input the first y coordinate: ";
    std::cin >> y1;
    std::cout << "Input the second x coordinate: ";
    std::cin >> x2;
    std::cout << "Input the second y coordinate: ";
    std::cin >> y2;


Also, that aside, nowhere do you check to make sure reasonable values were stored in the variables.

c++:
    slope = (y2 - y1) / (x2 - x1);


Hey look! We're finally putting a meaningful value in slope.

Instead of simple assignment here, let's declare slope here too.

c++:
    int slope = (y2 - y1) / (x2 - x1);


Now, let's use initialization syntax instead of assignment. Good practice to get into. You can only do this at declaration, though.

c++:
    int slope((y2 - y1) / (x2 - x1));


But there's still a likely problem. In C++, when you divide an int by an int, you get an int. You likely want to be able to get a floating point number, to represent slopes like 1/2.

To do this our slope should have a type of double, and we'll have to cast at least one of the argument to double as well.

c++:
    double slope(static_cast<double>(y2 - y1) / (x2 - x1));


c++:
     cout << "The slope is: " << slope << ".\n";
    cin.get();


Again, specify that cout and cin live in the std namespace.

Also, when you want a newline, do something like the following instead.

c++:
     std::cout << "The slope is: " << slope << "." << std::endl;
    std::cin.get();


And that's all for now. Smile
Author:  1of42 [ Sun Jun 26, 2005 7:12 pm ]
Post subject: 
For starters, I would personally ignore wtd. His idea of easy is to have to use the command line to get to the directory containing your files, and to compile everything manually. While less obfuscated, it is in fact not easier. Personally, I think you're better off with an IDE - especially one like Dev-C++, where you can ignore projects and other crap until you're comfortable with the language itself. Just press F9 and you're set.

On to your question:

c++:
#include <iostream.h>

That's bad. Remove the .h to make:
c++:
#include <iostream>

C++ header files do not require the .h at the end.

c++:
main()

Should be:
c++:
int main()

Your program must return a status to the operating system at the end of execution. So add this at the end:
c++:
return 0;

This indicates successful completion

Now you must use your identifiers. Either:

c++:
using namespace std;

or
c++:
using std::cout;
using std::cin;

or qualifying all your identifiers, like so:
c++:

    std::cout << "Input the first x coordinate: ";
    std::cin >> x1;
    std::cout << "Input the first y coordinate: ";
    std::cin >> y1;
    std::cout << "Input the second x coordinate: ";
    std::cin >> x2;
    std::cout << "Input the second y coordinate: ";
    vcin >> y2;
    slope = (y2 - y1) / (x2 - x1);
    std::cout << "The slope is: " << slope << ".\n";
    std::cin.get();


Also, make slope a double so you get decimals:
c++:
double slope;
slope = static_cast<double>(y2 - y1) / (x2 - x1);


Finally, after all that is corrected:

Create a new variables and cin to it:

c++:
int pauseVar;
cin >> pauseVar;


This will pause it.

*edit* Damn, wtd got to it first Wink

Just to note, wtd, that still doesn't solve the problem of the program finishing execution too fast to see, nor does it return a value to the OS, making the program fail compilation. Wink
Author:  Cinjection [ Sun Jun 26, 2005 7:25 pm ]
Post subject: 
wtd, the kid said he just started C++. Why are you getting into typecasting and initilizing in his like second program? Also for crist's sake USE namespcae std. At least if you don't to fully use it, go

code:

using namespace cout::std
using namespace cin::std
//etc

Its annoying as hell, and is really not nessicery.
Author:  wtd [ Sun Jun 26, 2005 7:34 pm ]
Post subject: 
Cinjection wrote:
wtd, the kid said he just started C++. Why are you getting into typecasting and initilizing in his like second program? Also for crist's sake USE namespcae std. At least if you don't to fully use it, go

code:

using namespace cout::std
using namespace cin::std
//etc

Its annoying as hell, and is really not nessicery.


For one thing, what you posted isn't even remotely valid code. I think you want:

code:
using std::cout;
using std::cin


And it's important for new programmers to see "std::" appended to things. It's vital to know where these things are coming from.

Type-casting is a part of the C++ language, and an important part. How else would you propose he get division of two integers to return a (meaningful) floating-point value?

Initialization vs. assignment is also a vital concept to understand.

Of course, these little subtleties are a damn good reason why C++ makes a poor choice for a language one learns early in their career.

Make sure you know what you're talking about before trying to give advice.
Author:  Cinjection [ Sun Jun 26, 2005 7:36 pm ]
Post subject: 
This is nice and easy and it works syntax wise. It sould also be correct in terms of logic, considering i wrote my equation of the line exam last wendsday Very Happy Very Happy Very Happy .
code:

#include <iostream>

using namespace std;

int main(){
       
        double x1,x2,y1,y2,slope,rise,run = 0; //or (0) if you want wtd :p

    cout << "Input the first x coordinate: ";
    cin >> x1;
    cout << "Input the first y coordinate: ";
    cin >> y1;
    cout << "Input the second x coordinate: ";
    cin >> x2;
    cout << "Input the second y coordinate: ";
    cin >> y2;

        rise = y2 - y1;
        run = x2 - x1;

        cout<<rise<<endl;
        cout<<"---"<<endl;
        cout<<run<<endl;

        slope = rise / run;

        cout<<"Slope as a decimal: "<<slope<<endl;;
       
        fflush(stdin); //bah i know i know, i like it and it works. C is //better then C++ in somethings.(like IO)
        cin.get();
        return 0;

}


EDIT: Sorry about the std::cout thing. Mind's in the gutter! Sad
Author:  wtd [ Sun Jun 26, 2005 7:41 pm ]
Post subject: 
c++:
cout<<rise<<endl;
cout<<"---"<<endl;
cout<<run<<endl


At the very leat make the above look like:

code:
cout << rise  << endl
     << "---" << endl
     << run   << endl;


For the love of everything good and wholesome, use spaces around operators, people.
Author:  [Gandalf] [ Sun Jun 26, 2005 7:56 pm ]
Post subject: 
First off, wow, thanks for all the help!

Quote:
His idea of easy is to have to use the command line to get to the directory containing your files, and to compile everything manually. While less obfuscated, it is in fact not easier. Personally, I think you're better off with an IDE - especially one like Dev-C++, where you can ignore projects and other crap until you're comfortable with the language itself. Just press F9 and you're set.

Well, personally, one of the bigger problems I had with DevC++ is that you need projects. Are you telling me that you don't? I don't know, I still have to make up my mind...

I'll try comprehending all this while still learning new stuff. There's so much things, and yet I have things like class' and constructors ahead of me.
Author:  Cinjection [ Sun Jun 26, 2005 8:06 pm ]
Post subject: 
wtd wrote:

For the love of everything good and wholesome, use spaces around operators, people.


Now to actually draw my line. Where'd I put my DirectX book..... Very Happy
Author:  wtd [ Sun Jun 26, 2005 8:15 pm ]
Post subject: 
Cinjection wrote:
wtd wrote:

For the love of everything good and wholesome, use spaces around operators, people.


Now to actually draw my line. Where'd I put my DirectX book..... Very Happy


That explais your love of mixing C and C++. Microsoft has always had a hard time figuring out that C++ is an entirely new language that just happens to look a lot like C.
Author:  Cinjection [ Sun Jun 26, 2005 8:27 pm ]
Post subject: 
wtd wrote:
Cinjection wrote:
wtd wrote:

For the love of everything good and wholesome, use spaces around operators, people.


Now to actually draw my line. Where'd I put my DirectX book..... Very Happy


That explais your love of mixing C and C++. Microsoft has always had a hard time figuring out that C++ is an entirely new language that just happens to look a lot like C.


heh. I hope you're not one of those anti-windows nazis....are you?
Author:  wtd [ Sun Jun 26, 2005 8:35 pm ]
Post subject: 
Cinjection wrote:
wtd wrote:
Cinjection wrote:
wtd wrote:

For the love of everything good and wholesome, use spaces around operators, people.


Now to actually draw my line. Where'd I put my DirectX book..... Very Happy


That explais your love of mixing C and C++. Microsoft has always had a hard time figuring out that C++ is an entirely new language that just happens to look a lot like C.


heh. I hope you're not one of those anti-windows nazis....are you?


I am. Unlike a lot of people I hate it for the right reasons, though. Smile

That said, I care more about helping people learn programming than convincing them to switch OSes. Plus, GCC runs just fine on Windows. A testament to the power of OSS.
Author:  1of42 [ Sun Jun 26, 2005 9:40 pm ]
Post subject: 
[Gandalf] wrote:
Well, personally, one of the bigger problems I had with DevC++ is that you need projects. Are you telling me that you don't? I don't know, I still have to make up my mind...

I'll try comprehending all this while still learning new stuff. There's so much things, and yet I have things like class' and constructors ahead of me.


Nope, you don't need projects. Press Ctrl+N for a new source file, then save it as you like and press F9 to compile and run it.

Projects are only really necessary when you have lots of different source fiels, and when you're creating WinAPI or OpenGL/DirectX apps, which need to have a project of type Windows Application to look right (no unnecessary console)
Author:  md [ Sun Jun 26, 2005 10:08 pm ]
Post subject: 
Just a side note about declairing variables; while C++ allows you to declare a variable anywhere in your function it's still best to declare the variable at the top of the function. The reason? Say you go back and change some code, if you happen to use a variable of the same name in your new code as a variable that is declared later in your old code you'll get a compile error. While it's simple to fix it's still a pain to have to go back and fix that one thing because you couldn't keep track of your variables.
Author:  [Gandalf] [ Sun Jun 26, 2005 10:11 pm ]
Post subject: 
Cinjection wrote:
wtd wrote:

For the love of everything good and wholesome, use spaces around operators, people.


Now to actually draw my line. Where'd I put my DirectX book..... Very Happy

Does C++ have any basic drawing functions? I know C allows you to draw simple shapes and stuff like that without using DirectX or OpenGL.

Ok, here's my new program, the sum of my trials today. I don't understand some of the stuff in it yet, but I will make every effort to Smile.

c++:
#include <iostream>
#include <string>

class sum {
public:
          int current;
          void add(int value);
} number;

void sum::add(int value)
{
     current += value;
}

int main()
{
    int x1, y1, x2, y2;
    std::string name;

    std::cout << "Hello, what is your name? ";
    std::cin >> name;
    std::cout << std::endl << "Input the first x coordinate: ";
    std::cin >> x1;
    std::cout << "Input the first y coordinate: ";
    std::cin >> y1;
    std::cout << "Input the second x coordinate: ";
    std::cin >> x2;
    std::cout << "Input the second y coordinate: ";
    std::cin >> y2;
    double slope(static_cast<double>(y2 - y1) / (x2 - x1));
    std::cout << std::endl << name << ", the slope is: " << slope << "." << std::endl;

    number.current = 0;
    std::cout << std::endl << "Input the number you want to start with: ";
    std::cin >> number.current;
    number.add(5);
    std::cout << std::endl << "That number plus 5 is " << number.current << "." << std::endl;
    number.add(78);
    std::cout << "That number plus 78 is " << number.current << "." << std::endl;

    std::cout << std::endl << "Press any key to exit.";
    std::cin.ignore(1,'\n');
    std::cin.ignore();
    return 0;
}

It should work, if it doesn't well... Let's hope its a result of my tiredness.

Thanks again to all those who helped today and will later on as well!
Author:  wtd [ Mon Jun 27, 2005 12:34 am ]
Post subject: 
Cornflake wrote:
Just a side note about declairing variables; while C++ allows you to declare a variable anywhere in your function it's still best to declare the variable at the top of the function. The reason? Say you go back and change some code, if you happen to use a variable of the same name in your new code as a variable that is declared later in your old code you'll get a compile error. While it's simple to fix it's still a pain to have to go back and fix that one thing because you couldn't keep track of your variables.


Actually, declaring at the top of the function is not a good practice to get into. As you say, the compiler will track down errors for you. Use the compiler. It has no feelings, and doesn't mind hard, tedious work. Wink

The problem is that you should get into the habit of using "const" as much as possible. That is, variables should primarily be viewed as convenient names given to constant values. This way the compiler can track down any unintended changes in the variable's content. If you separately declare and initialize your variables, this becomes impossible. Smile
Author:  wtd [ Mon Jun 27, 2005 1:32 am ]
Post subject: 
Let's look at your class.

c++:
class sum {
public:
          int current;
          void add(int value);
} number;

void sum::add(int value)
{
     current += value;
}


First, let's just deal with the class. We can create the "number" instance of the class later, in "main", like so:

[syntax="cpp"]sum number;[/code]

We're left with:

c++:
class sum
{
   public:
      int current;
      void add(int value);
};

void sum::add(int value)
{
   current += value;
}


Now, we can have classes where all members (both data and function) are public. But a shortcut for that is to call the class a "struct". In C++ classes and structs are identical, except that members are public by default in structs.

c++:
struct sum
{
   int current;
   void add(int value);
};

void sum::add(int value)
{
   current += value;
}


But that's not right. The variable "current" shouldn't be accessible from outside the class, because that means we can change it in all kinds of uncouth ways.

So we make the variable private, and the functions which manipulate it public. Oh, and the "value" passed to "add" can be a consant int.

c++:
class sum
{
   private:
      int current;
   public:
      void add(const int value);
};

void sum::add(const int value)
{
   current += value;
}


Of course, now you ask, how do I initialize a sum object?

For that, we use a constructor. We'll have both a default constructor that takes no arguments, and one which takes an initial value.

c++:
class sum
{
   private:
      int current;
   public:
      sum();
      sum(const int value);

      void add(const int value);
};

void sum::add(const int value)
{
   current += value;
}


Now we'll define the constructors.

c++:
class sum
{
   private:
      int current;
   public:
      sum();
      sum(const int value);

      void add(const int value);
};

sum::sum() : current(0) { }

sum::sum(const int value) : current(value) { }

void sum::add(const int value)
{
   current += value;
}


Now, when we declare "number" like so:

c++:
sum number;


"current" gets set to zero.

Or we could declare and initialize like so:

c++:
sum number(42);


Here "current" is initialized to 42.

Of course, we'll need a way to get at the current value. I know! How about a "current_value" member function?

c++:
class sum
{
   private:
      int current;
   public:
      sum();
      sum(const int value);

      void add(const int value);

      int current_value();
};

sum::sum() : current(0) { }

sum::sum(const int value) : current(value) { }

void sum::add(const int value)
{
   current += value;
}

int sum::current_value()
{
   return current;
}


Of course, we aren't changing anything about the object when we call the "current_value" function. So we tell the compiler that it's ok to call that function on a constant sum object.


c++:
class sum
{
   private:
      int current;
   public:
      sum();
      sum(const int value);

      void add(const int value);

      int current_value() const;
};

sum::sum() : current(0) { }

sum::sum(const int value) : current(value) { }

void sum::add(const int value)
{
   current += value;
}

int sum::current_value() const
{
   return current;
}


Now, that's pretty good. What if we want to sum floating-point numbers?

We could write a whole new class. It'd be mostly copy and paste. But, isn't there a better way?

There is. We call them templates.

c++:
template <typename _t>
class sum
{
   private:
      _t current;
   public:
      sum();
      sum(const _t value);

      void add(const _t value);

      _t current_value() const;
};

template <typename _t>
sum<_t>::sum() : current(0) { }

template <typename _t>
sum<_t>::sum(const _t value) : current(value) { }

template <typename _t>
void sum<_t>::add(const _t value)
{
   current += value;
}

template <typename _t>
_t sum<_t>::current_value() const
{
   return current;
}


Now I can have "number" again by writing:

[syntax="cpp"]sum<int> number;[/code]

Of course, the next question is... why have an "add" function. That sounds and awful lot like the + operator.

c++:
template <typename _t>
class sum
{
   private:
      _t current;
   public:
      sum();
      sum(const _t value);

      _t operator+(const _t value) const;
      _t operator+=(const _t value);

      _t current_value() const;
};

template <typename _t>
sum<_t>::sum() : current(0) { }

template <typename _t>
sum<_t>::sum(const _t value) : current(value) { }

template <typename _t>
_t sum<_t>::operator+(const _t value) const
{
   return current + value;
}



Now, to rewrite your original program. Smile

c++:
#include <iostream>
#include <string>

template <typename _t>
class sum
{
   private:
      _t current;
   public:
      sum();
      sum(const _t value);

      _t operator+(const _t value) const;
      _t operator+=(const _t value);

      _t current_value() const;
};

int main()
{
   std::string name;

   std::cout << "Hello, what is your name? ";
   std::cin >> name;

   std::cout << std::endl;

   int x1, y1, x2, y2;

   std::cout << "Input the first x coordinate: ";
   std::cin >> x1;
   std::cout << "Input the first y coordinate: ";
   std::cin >> y1;
   std::cout << "Input the second x coordinate: ";
   std::cin >> x2;
   std::cout << "Input the second y coordinate: ";
   std::cin >> y2;

   std::cout << std::endl;
   
   double slope(static_cast<double>(y2 - y1) / (x2 - x1));

   std::cout << name << ", the slope is: " << slope << "." << std::endl;

   std::cout << std::endl;

   int initial_value;

   std::cout << "Input the number you want to start with: ";
   std::cin >> initial_value;

   sum<int> number(initial_value);

   number += 5;

   std::cout << std::endl;

   std::cout << "That number plus 5 is " << number.current_value() << "." << std::endl;
   number += 78;
   std::cout << "That number plus 78 is " << number.current_value() << "." << std::endl;

   std::cout << std::endl << "Press any key to exit.";
   std::cin.ignore(1,'\n');
   std::cin.ignore();

   return 0;
}

template <typename _t>
sum<_t>::sum() : current(0) { }

template <typename _t>
sum<_t>::sum(const _t value) : current(value) { }

template <typename _t>
_t sum<_t>::operator+(const _t value) const
{
   return current + value;
}

template <typename _t>
_t sum<_t>::operator+=(const _t value)=
{
   return current += value;
}

template <typename _t>
_t sum<_t>::current_value() const
{
   return current;
}


But we've got some really inefficient stuff like the code required to read in a value and put that in "current". As well, on output, calling current_value() looks bad. Let's streamline that.

c++:
#include <iostream>
#include <string>

template <typename _t>
class sum
{
   private:
      _t current;
   public:
      sum();
      sum(const _t value);

      _t operator+(const _t value) const;
      _t operator+=(const _t value);

      _t current_value() const;

      template <typename __t>
      friend std::istream& operator>>(std::istream& in, const sum<__t>& s);

      template <typename __t>
      friend std::ostream& operator<<(std::ostream& out, const sum<__t>& s);
};

int main()
{
   std::string name;

   std::cout << "Hello, what is your name? ";
   std::cin >> name;

   std::cout << std::endl;

   int x1, y1, x2, y2;

   std::cout << "Input the first x coordinate: ";
   std::cin >> x1;
   std::cout << "Input the first y coordinate: ";
   std::cin >> y1;
   std::cout << "Input the second x coordinate: ";
   std::cin >> x2;
   std::cout << "Input the second y coordinate: ";
   std::cin >> y2;

   std::cout << std::endl;
   
   double slope(static_cast<double>(y2 - y1) / (x2 - x1));

   std::cout << name << ", the slope is: " << slope << "." << std::endl;

   std::cout << std::endl;

   sum<int> number;

   std::cout << "Input the number you want to start with: ";
   std::cin >> number;

   number += 5;

   std::cout << std::endl;

   std::cout << "That number plus 5 is " << number << "." << std::endl;
   number += 78;
   std::cout << "That number plus 78 is " << number << "." << std::endl;

   std::cout << std::endl << "Press any key to exit.";
   std::cin.ignore(1,'\n');
   std::cin.ignore();

   return 0;
}

template <typename _t>
sum<_t>::sum() : current(0) { }

template <typename _t>
sum<_t>::sum(const _t value) : current(value) { }

template <typename _t>
_t sum<_t>::operator+(const _t value) const
{
   return current + value;
}

template <typename _t>
_t sum<_t>::operator+=(const _t value)=
{
   return current += value;
}

template <typename _t>
_t sum<_t>::current_value() const
{
   return current;
}

template <typename __t>
std::istream& operator>>(std::istream& in, const sum<__t>& s)
{
   return in >> s.current;
}

template <typename __t>
std::ostream& operator<<(std::ostream& out, const sum<__t>& s)
{
   return out << s.current;
}
Author:  wtd [ Mon Jun 27, 2005 1:36 am ]
Post subject: 
Of course, if we put all of the class into a file named "sum.h".

c++:
#include <iostream>

template <typename _t>
class sum
{
   private:
      _t current;
   public:
      sum();
      sum(const _t value);

      _t operator+(const _t value) const;
      _t operator+=(const _t value);

      _t current_value() const;

      template <typename __t>
      friend std::istream& operator>>(std::istream& in, const sum<__t>& s);

      template <typename __t>
      friend std::ostream& operator<<(std::ostream& out, const sum<__t>& s);
};

template <typename _t>
sum<_t>::sum() : current(0) { }

template <typename _t>
sum<_t>::sum(const _t value) : current(value) { }

template <typename _t>
_t sum<_t>::operator+(const _t value) const
{
   return current + value;
}

template <typename _t>
_t sum<_t>::operator+=(const _t value)=
{
   return current += value;
}

template <typename _t>
_t sum<_t>::current_value() const
{
   return current;
}

template <typename __t>
std::istream& operator>>(std::istream& in, const sum<__t>& s)
{
   return in >> s.current;
}

template <typename __t>
std::ostream& operator<<(std::ostream& out, const sum<__t>& s)
{
   return out << s.current;
}


Then our program can look like:

c++:
#include <iostream>
#include <string>
#include "sum.h"

int main()
{
   std::string name;

   std::cout << "Hello, what is your name? ";
   std::cin >> name;

   std::cout << std::endl;

   int x1, y1, x2, y2;

   std::cout << "Input the first x coordinate: ";
   std::cin >> x1;
   std::cout << "Input the first y coordinate: ";
   std::cin >> y1;
   std::cout << "Input the second x coordinate: ";
   std::cin >> x2;
   std::cout << "Input the second y coordinate: ";
   std::cin >> y2;

   std::cout << std::endl;
   
   double slope(static_cast<double>(y2 - y1) / (x2 - x1));

   std::cout << name << ", the slope is: " << slope << "." << std::endl;

   std::cout << std::endl;

   sum<int> number;

   std::cout << "Input the number you want to start with: ";
   std::cin >> number;

   number += 5;

   std::cout << std::endl;

   std::cout << "That number plus 5 is " << number << "." << std::endl;
   number += 78;
   std::cout << "That number plus 78 is " << number << "." << std::endl;

   std::cout << std::endl << "Press any key to exit.";
   std::cin.ignore(1,'\n');
   std::cin.ignore();

   return 0;
}
Author:  [Gandalf] [ Mon Jun 27, 2005 6:54 pm ]
Post subject: 
Yes... ::blank face::

Thanks for fixing my program... Smile Ok, now I spend the next 2 years trying to figure all that out. I got lost somewhere between defining constructors and the rest of the explanation. I'm learning from a book too, and I was just starting constructors. I think you just got to about the end of the book and beyond (its mostly about C, but it has some C++).

Well, ok, erm... I guess I will try understanding all that. One step at a time. I was aware of private, public, and protected variables and member functions, but the book just left it at public till a bit later.

Your final class is very confusing, I will read your post a few more times.
Do you think I should leave classes till later? Or well, what do you suggest? Should I try and push myself to figure out everything you posted? From what I have right now, this is how I would edit the program.
c++:
#include <iostream>
#include <string>

class sum {
private:
          int current;
public:
          sum(void);
          void add(int value);
} number;

sum:sum()
{
     current = 0;
}

void sum::add(int value)
{
     current += value;
}

int main()
{
    int x1, y1, x2, y2;
    std::string name;

    std::cout << "Hello, what is your name? ";
    std::cin >> name;
    std::cout << std::endl << "Input the first x coordinate: ";
    std::cin >> x1;
    std::cout << "Input the first y coordinate: ";
    std::cin >> y1;
    std::cout << "Input the second x coordinate: ";
    std::cin >> x2;
    std::cout << "Input the second y coordinate: ";
    std::cin >> y2;
    double slope(static_cast<double>(y2 - y1) / (x2 - x1));
    std::cout << std::endl << name << ", the slope is: " << slope << "." << std::endl;

    std::cout << std::endl << "Input the number you want to start with: ";
    std::cin >> number.current;
    number.add(5);
    std::cout << std::endl << "That number plus 5 is " << number.current << "." << std::endl;
    number.add(78);
    std::cout << "That number plus 78 is " << number.current << "." << std::endl;

    std::cout << std::endl << "Press any key to exit.";
    std::cin.ignore(1,'\n');
    std::cin.ignore();

    return 0;
}

Am i correct in assuming that when you do something like sum(void); and sum(); that they are the same?

Also, I also realized that you can declare the object in three different kinds of ways (from what I know). Personally, I don't know the difference yet, but having it right after the class seems simplest to me.

Thanks for the detailed help. I'll get back to this later.

Oh, and importantly, the thing that got me lost at the constructors was that you were declaring it with arguments? So what would that do, allow you to set the initial value of "current"?
Author:  wtd [ Mon Jun 27, 2005 9:03 pm ]
Post subject: 
Yes, a constructor that takes arguments can be used to initialize member variables. Since your member variables are almost always going to be private or protected, this should be the only way you have available to initialize them.

For instance, you have "current" being private, but then you try to access it externally:

code:
std::cin >> number.current;


The private qualifier means that "current" is inaccessible from outside the class. This prevents any bit of code from changing the internal state of an object in weird ways.


One classic example is a car. Let's give our car four wheels. Let's also make everything public.

c++:
struct car
{
   int wheels[4];

   car()
   {
      for (int i (0); i < 4; ++i)
         wheels[i] = 0;
   }

   car(const int initial_speed)
   {
      for (int i (0); i < 4; ++i)
         wheels[i] = initial_speed;
   }
};


Now, maybe I'll add an increase speed function.

c++:
struct car
{
   int wheels[4];

   car()
   {
      for (int i (0); i < 4; ++i)
         wheels[i] = 0;
   }

   car(const int initial_speed)
   {
      for (int i (0); i < 4; ++i)
         wheels[i] = initial_speed;
   }

   void increase_speed(const int amount)
   {
      for (int i (0); i < 4; ++i)
         wheels[i] += amount;
   }
};


But, we can still individually access the wheels.

c++:
car elise(40);

car.wheels[2] += 80;


Now, what happens when we have three wheels going 40KPH, and one going 120KPH? Bad, bad things happen. Smile

If the wheels array was private, it wouldn't be a problem.
Author:  [Gandalf] [ Tue Jun 28, 2005 3:28 pm ]
Post subject: 
Ok, so how would I change "current" in my program, should I make a seperate member function in the class, or something else?

This is what I was working on today, I think I got the while loop in proper C++ style.

c++:
#include <iostream>
#include <string>

class counter {
public:
       int count;
       counter(int start);
       ~counter(void);
       void adder(int amount);
};

counter::counter(int start)
{
                     count = start;
                     std::cout << std::endl << "The counter's initial value is: " << count << "." << std::endl;
}

void counter::adder(int amount)   
{
     count += amount;
     std::cout << "The counter is currently at: " << count << ".\n";
}

counter::~counter()
{
                   std::cout << "The final value of the counter is: " << count << "." << std::endl;
}                   

void getlimits(void);
void countloop(void);
int tempstart;   // For the counter constructor.
int tempamount;  // For the adder function in the counter class.
int countlimit;

main()
{
    std::string name;

    std::cout << "Hello, what is your name? ";
    std::cin >> name;
    getlimits();
    countloop();
    std::cout << std::endl << "Press any key to exit.";
    std::cin.ignore(1,'\n');
    std::cin.ignore();
    return 0;
}

void getlimits()
{   
     std::cout << "What integer would you like the counter to start at? ";
     std::cin >> tempstart;
     std::cout << "What integer would you like the counter to end at? ";
     std::cin >> countlimit;
     std::cout << "By how much (integer) would you like the counter to count by? ";
     std::cin >> tempamount;
}

void countloop()
{
     counter doloop(tempstart);
     
     std::cout << std::endl << "Beginning of counting loop." << std::endl;
     while (doloop.count < countlimit - tempamount)
               doloop.adder(tempamount);
     std::cout << "End of the counting loop." << std::endl << std::endl;
}
Author:  wtd [ Tue Jun 28, 2005 4:24 pm ]
Post subject: 
Well, there are several points I should make.

General Theory

First off, in object-oriented programming, we have both member variables, and member functions. Understanding the different roles of these is critical.

Member variables exist to keep track of the internal state of an object. In the car example, we had a 4 element array of integers to represent the speed of each of the wheels on a car.

Member functions exist to manipulate those variables in a controlled way.

Because of this relationship, we want member variables generally to be private, and thus inaccessible from outside the class, and member functions to be public.

On Constructors & Destructors

Constructors and destructors should not print output. This makes it impossible to use them in places where you don't want that output.

Constructors should always use initialization syntax unless it's not possible. Rather than:

c++:
class name
{
   private:
      std::string first, last;
   public:
      name(std::string f, std::string l)
      {
         first = f;
         last = l;
      }
};


I should use:

c++:
class name
{
   private:
      std::string first, last;
   public:
      name(std::string f, std::string l)
      : first(f), last(l)
      { }
};


Destructors should only be used where you have some dynamically allocated member variable(s). Otherwise there's no need to create a destructor.

Member Names

Member functions names should fall into a few categories. Functions swhich return some value should have noun names. You may wish to prefix these with "get" in some way. Member functions which return a boolean value should have names starting with something like "is" or "has".

Member functions that change something about the object should have verb names like "add", "subtract", etc.
Author:  [Gandalf] [ Thu Jun 30, 2005 9:16 pm ]
Post subject: 
Ok, I understand that, thanks.

I'm not sure though. I can't make up my mind as to which language I should learn. Do you think I am getting a pretty good start on C++? Or should I try going down a step to C, without worrying about all the object-oriented stuff? I was also looking at Java, it seems a bit easier, and closer to Turing, which I already have some experience with. For example this:
Java:
import java.util.*;

public class fiveElDoubleArray
{
        public static void main (String[] args)
        {
       
        for (int i = 0; i < 5; i++) {
                sum +=  rand.nextInt
                       
        double[] array = {45.6745, 45345.2342, 67353231.135452431, -341.23, 101.98};
        System.out.println(array);
        }
        }
}


Not sure, C++ seems useful, and I think I know most of what I've read, but it might get too complicated later on...
*sigh* I have no idea... I might just try a little bit of everything and see which works best? I've gained a lot of programming knowledge since I last tried Java, and C as well.
Author:  wtd [ Thu Jun 30, 2005 9:40 pm ]
Post subject: 
Well, C++ and Java may seem useful to you, but here's a handy tip: if it frustrates you to the point where you never get to the useful stuff... then it's not useful to you.

I say keep going. You're doing well. Just take it one step at a time, and if you have questions... ask!
Author:  [Gandalf] [ Fri Jul 01, 2005 7:35 pm ]
Post subject: 
Alright then.

Something that came across me when writing my small answers to your questions was; the reason that my program doesn't output the numbers properly is probably because it is using the postfix form of incrementing. So, how would I use the prefix form when I'm not doing it by 1, but by a variable? The 'problem' i speak of is that it doesn't output the final value of the counter.

Also, what does "static" mean? When you say something like static int 4; or something of that sort.

I am having trouble changing everything from public in my previously posted program. Could you give an example of how it would work in this case? I'll have to work on it some more.

Also, what is an "object stack"? Is it just a group of objects from the same class? What do "[]" those mean as opposed to "()"?
Author:  wtd [ Fri Jul 01, 2005 7:55 pm ]
Post subject: 
[Gandalf] wrote:
Alright then.

Something that came across me when writing my small answers to your questions was; the reason that my program doesn't output the numbers properly is probably because it is using the postfix form of incrementing. So, how would I use the prefix form when I'm not doing it by 1, but by a variable? The 'problem' i speak of is that it doesn't output the final value of the counter.


I know this doesn't directly answer your question, but you should avoid use of global variables, as you did in the code you posted.

Variables should be declared with functions, and then passed to other functions as arguments. Now this becomes slightly different when dealing with objects, where the object's state is maintained by variables declared outside of a function's scope.

So, you want to write a counter class?

c++:
class counter
{

};


There's the basic framework. Now, we want a constructor which setsup the class with a default state.

c++:
class counter
{
   public:
      counter();
};


And we'll want a constructor to setup the object with an initial value of our choosing.

c++:
class counter
{
   public:
      counter();
      counter(const int initial_value);
};


We don't need to allocate any memory, so we don't need a destructor.

We will want to be able to get the current value of the counter object, so we'll have a member function to retrieve that information.

c++:
class counter
{
   public:
      counter();
      counter(const int initial_value);

      int current_value() const;
};


Now, we want a way to increment the counter by one.

c++:
class counter
{
   public:
      counter();
      counter(const int initial_value);

      int current_value() const;

      void increment();
};


And we'll overload that member function's name so we can deal with incrementing by an arbitrary amount.

c++:
class counter
{
   public:
      counter();
      counter(const int initial_value);

      int current_value() const;

      void increment();
      void increment(const int amount);
};


Now, let's implement this. But of course, we need some state to modify first.

c++:
class counter
{
   private:
      int value;
   public:
      counter();
      counter(const int initial_value);

      int current_value() const;

      void increment();
      void increment(const int amount);
};


Our default constructor, which sets value to zero:

c++:
counter::counter() : value(0) { }


Our other constructor:

c++:
counter::counter(const int initial_value) : value(initial_value) { }


The member function to retrieve the current value:

c++:
int counter::current_value() const
{
   return value;
}


And the increment member functions, with one defined in terms of the other:

c++:
void counter::increment()
{
   increment(1);
}

void counter::increment(const int amount)
{
   value += amount;
}


Now, taking this, we can declare a counter in our main function, with an initial value of 0, and loop until counter is 9, incrementing by 1 each time.

c++:
int main()
{
   counter c;

   while (counter.current_value() <= 9)
   {
      std::cout << counter.current_value() << std::endl;
      counter.increment();
   }
}


We could also put ths into for loop format:

c++:
int main()
{
   counter c;

   for ( ; counter.current_value() <= 9; counter.increment())
   {
      std::cout << counter.current_value() << std::endl;
   }
}
Author:  [Gandalf] [ Sat Jul 02, 2005 4:06 pm ]
Post subject: 
I'm pretty sure I got it. Still, I'm not really sure why and when to use classes, would it really be useful in that case?

Here, tell me if I got the whole passing to other functions as arguments things right. This is the guessing game I was working on yesterday. It works, but it seems like more trouble than it should be, maybe because I overused functions?
c++:
/*
Guessing Game Program Version 0.4
Started: July 1, 2005
*/

#include <iostream>
#include <string>
#include <ctime>

using namespace std;
void start(void);
void generate_number(int min, int max);
void check_limits(int min, int max);
void guess_time(int min, int max, int random_num, int guess_count);
void check_guess(int number, int random_num, int min, int max, int guess_count);

main()
{     
      start();     
      cin.ignore(1,'\n');
      cin.ignore();
      return 0;
}

void start()
{
     string name;
     int min_range, max_range;
     
     cout << "Gandalf's Guessing Game Version 0.4" << endl << "\n";
     cout << "Hello, what is your name? ";
     cin >> name;
     cout << "Hope you have fun playing the guessing game, " << name << "!" << endl;
     cout << endl << "Minimum number for the range of numbers? ";
     cin >> min_range;
     cout << "Maximum number for the range? ";
     cin >> max_range;
     check_limits(min_range, max_range);
     generate_number(min_range, max_range);
}

void check_limits(int min, int max)
{
     if (min > max | max < min)
        cout << "Invalid input, the program will not run properly, this bug will be fixed later";
}

void generate_number(int min, int max)
{   
     srand((unsigned)time(NULL));
     int random_number(rand() % (max-min+1) + min);
     cout << "Game starting... \n" << endl;
     int guess_count(0);
     guess_time(min, max, random_number, guess_count);
}

void guess_time(int min, int max, int random_num, int guess_count)
{
     int guess;
           
     cout << "Enter your guess (between " << min << " and " << max << "): ";
     cin >> guess;
     check_guess(guess, random_num, min, max, guess_count);     
}

void check_guess(int number, int random_num, int min, int max, int guess_count)
{
     if (number > random_num)
     {
        cout << "Too high!" << endl;
        ++guess_count;
        guess_time(min, max, random_num, guess_count);
     }
     else
     if (number < random_num)
     {
        cout << "Too low." << endl;
        ++guess_count;
        guess_time(min, max, random_num, guess_count);
     }
     else
     if (number == random_num)
     {
        cout << "You got the number!  Good job!" << endl;
        ++guess_count;
        cout << "It took you: " << guess_count << " guesses to get the number.";
     }
     else
         cout << "Invalid number" << endl;
}

I spent a long, long time on that Smile.
Author:  wtd [ Sat Jul 02, 2005 4:33 pm ]
Post subject: 
Speaking of places where you might want to use classes...

Notices how you pass along a min/max combination of numbers frequently? Well, what if we wrap that up into one package?

c++:
class bounds
{
   private:
      int min_bound, max_bound;
   public:
      bounds(const int initial_min, const int initial_max)
      : min_bound(initial_min)
      , max_bound(initial_max)
      { }
   
      int min() const { return min_bound; }
      int max() const { return max_bound; }
};


Of course, we can realize here that the state of the member variables will never change, so why not make them constant.

c++:
class bounds
{
   private:
      const int min_bound, max_bound;
   public:
      bounds(const int initial_min, const int initial_max)
      : min_bound(initial_min)
      , max_bound(initial_max)
      { }
   
      int min() const { return min_bound; }
      int max() const { return max_bound; }
};


And if the member variables can't be changed after initialization, why not allow direct access to them?

c++:
struct bounds
{
   const int min, max;
   
   bounds(const int initial_min, const int initial_max)
   : min(initial_min)
   , max(initial_max)
   { }
};
Author:  [Gandalf] [ Wed Jul 06, 2005 9:32 pm ]
Post subject: 
I see, so in this case it wouldn't matter that you can access the variables outside of the class/struct? The thing that really held me back from understanding your class/struct was the syntax you are using.

A question, is there a more 'convenient' way of defining many things as one... This is what I mean, is there a way to change it?

c++:
#define yes "ya"
#define yes "yep"
#define yes "y"
#define no "nope
#define no "n
//and so on...
Author:  1of42 [ Wed Jul 06, 2005 9:54 pm ]
Post subject: 
[Gandalf] wrote:
I see, so in this case it wouldn't matter that you can access the variables outside of the class/struct? The thing that really held me back from understanding your class/struct was the syntax you are using.

A question, is there a more 'convenient' way of defining many things as one... This is what I mean, is there a way to change it?

c++:
#define yes "ya"
#define yes "yep"
#define yes "y"
#define no "nope
#define no "n
//and so on...


Well, you could make a const array of strings, but jut for the record, your code there is not valid - the preprocessor will overwrite each successive definition after it's defined, only "y" and "n" will remain defined.
Author:  wtd [ Wed Jul 06, 2005 10:10 pm ]
Post subject: 
Please don't use preprocessor macros.

As 1of42 alluded to, use an array, or some other kind of collection-ish thing.

An array:

c++:
const std::string valid_affirmative_answers[] = {"ya", "yep", "y"};


And then to check and see if we have a valid answer...

code:
// assume the answer is stored in "answer"

bool valid_answer(false);

for (int i(0); i < 3 && !valid_answer; ++i)
{
   if (answer == valid_affirmative_answers[i])
      valid_answer = true;
}
Author:  [Gandalf] [ Wed Jul 06, 2005 10:21 pm ]
Post subject: 
Thanks! I wasn't thinking 'outside the' little box I created for myself Smile. Should I never use macros? or just not in this way?
Author:  wtd [ Wed Jul 06, 2005 10:24 pm ]
Post subject: 
[Gandalf] wrote:
Thanks! I wasn't thinking 'outside the' little box I created for myself Smile. Should I never use macros? or just not in this way?


Try not to use them ever in C++.

The biggest problem, as I see it, is that with macros you end up seeing a different piece of source code than the compiler.
Author:  md [ Thu Jul 07, 2005 9:37 am ]
Post subject: 
One of the most annoying bugs I've ever run across was because some bright light as MS decided that instead of making teh GetObject function a real function (it's part of the GDI) they'd make it a marco to the function apropriate to if you were using a wide characters or not. So when I wrote my own GetObject function as part of one of my classes which used something in windows.h, which pulled in the GDI (bah!) it broke because of the stupid redefinition of some moron. So yeah... preprocessor macros == bad.
Author:  [Gandalf] [ Fri Jul 08, 2005 10:26 pm ]
Post subject: 
Ok, for now I'll hold of on them.

I'm confused as to why some books start out with just a simple int main(); function, and why some do something weird (to me) like:
code:
int main(int argc, char *argv[])


Also, I read that you can simple put the function above the main() one, and you don't have to declare it, like so:
c++:
#include <iostream>

void greet()
{
   std::cout << "Hello world" << std::endl;
}

int main()
{
   greet();
   return 0;
}

I haven't been able to try compiling it (lack of access) but if it does work then which method is better?

*edit*
Oh, and I remember wtd mentioning that arrays are bad and one reason was because you can't tell the upper bounds (I think that was it). Can you just have a dynamic array and check that variable for the size?
Author:  wtd [ Fri Jul 08, 2005 10:48 pm ]
Post subject: 
[Gandalf] wrote:
Ok, for now I'll hold of on them.

I'm confused as to why some books start out with just a simple int main(); function, and why some do something weird (to me) like:
code:
int main(int argc, char *argv[])


You can pass arguments to a program when you start it. You've most likely already seen this. You run "g++ my_program.cpp" to compile your program. In this case "my_program.cpp" is an argument to the program.

How do you get at these arguments? Well, they get passed as arguments to the main function, as an array of character arrays (C "strings"). Since C and C++ arrays don't keep track of their size, it also passes in the size of the array as "argc".

[Gandalf] wrote:
Also, I read that you can simple put the function above the main() one, and you don't have to declare it, like so:
c++:
#include <iostream>

void greet()
{
   std::cout << "Hello world" << std::endl;
}

int main()
{
   greet();
   return 0;
}

I haven't been able to try compiling it (lack of access) but if it does work then which method is better?


It will work, and for programs of this size, it's largely a question of style. You see, the compiler needs two pieces of information about a function before another function can call it. It needs to know what type of data the function takes as arguments, and it needs to know what type of data the function returns.

With this information it can check to make sure types are being used appropriately. Using a forward declaration along the lines of:

c++:
void greet();

int main()
{
   greet();
}


Gives the compiler that information.

[Gandalf] wrote:
*edit*
Oh, and I remember wtd mentioning that arrays are bad and one reason was because you can't tell the upper bounds (I think that was it). Can you just have a dynamic array and check that variable for the size?


The best solution is to use the std::vector class. The std::vector class is a templated one. That means there's no actual executable code, but rather a "pattern" of sorts. Based on the template parameters, the compiler then generates the appropriate code at compile-time.

This means there doesn't have to be a std::int_vector class and a std::double_vector class, and a std::string_vector class. Smile

So, using a std::vector...

c++:
#include <vector>

int main()
{
   std::vector<int> grades;
   grades.push_back(42);
   grades.push_back(78);
   grades.push_back(89);

   std::cout << "There are " << grades.size() << " grades." << std::endl;

   return 0;
}
Author:  [Gandalf] [ Sun Jul 10, 2005 4:27 pm ]
Post subject: 
Thanks again, always a help! Smile

So, is there a way to add in lots of 'grades' without having to write the grades.push_back every time? Other than a for loop?
Author:  wtd [ Sun Jul 10, 2005 4:41 pm ]
Post subject: 
[Gandalf] wrote:
Thanks again, always a help! Smile

So, is there a way to add in lots of 'grades' without having to write the grades.push_back every time? Other than a for loop?


Not really, but as you say, with a loop it isn't much trouble.

c++:
#include <vector>
#include <iostream>

int main()
{
   std::vector<int> grades(10); // pre-allocate space for ten ints
   
   for (int i(0); i < 10; ++i)
   {
      int temp;
     
      while (true)
      {
         std::cout << "Enter a grade: ";
         std::cout.flush(); // make sure line buffering doesn't screw up the output
     
         std::cin >> temp;

         if (!std::cin.fail()) break;
         std::cout << "Please enter a valid grade." << std::endl;
      }
   
      grades.push_back(temp);
   }

   return 0;
}
Author:  wtd [ Sun Jul 10, 2005 4:57 pm ]
Post subject: 
Of course, if you don't like creating the temp variable, you could always create your own class which wraps a std::istream. Smile

c++:
#include <iostream>
#include <pair>
#include <vector>

class my_istream
{
   private:
      std::istream& in;
   public:
      explicit my_istream(std::istream& in_stream);
 
      template <typename _t> _t get_value();
      template <typename _t> std::pair<_t, bool> get_value_and_status();

      bool fail() const;
};

explicit my_stream::my_istream(std::istream& in_stream)
: in(in_stream)
{ }

template <typename _t>
_t my_istream::get_value()
{
   _t temp;
   in >> temp;
   return temp;
}

template <typename _t>
std::pair<_t, bool> my_istream::get_value_and_status()
{
   return std::pair<_t, bool>(get_value(), fail());
}

bool my_istream::fail() const
{
   return in.fail();
}


untested
Author:  [Gandalf] [ Sun Jul 10, 2005 5:07 pm ]
Post subject: 
Wow Shocked . Considering the first was at the limit of my knowledge, the seconds seems a bit complicated. Maybe I'll look back in a little while and understand Smile.
Author:  wtd [ Sun Jul 10, 2005 8:16 pm ]
Post subject: 
Well, if it works, you could create a my_istream variable which wraps std::cin.

c++:
my_istream in(std::cin);


Then get an int from std::cin like so:

c++:
int main()
{
   my_istream in(std::cin);
   std::vector<int> grades(10);

   std::cout << "Input grade: ";
   std::cout.flush();

   grades.push_back(in.get_value<int>());

   return 0;
}
Author:  jamonathin [ Sun Jul 10, 2005 8:45 pm ]
Post subject: 
I read through this entire post just now, and you remind me of, well me when I first started this Gandalf. This is about where I left off. I got distracted by the games being made in Turing, and I spent all of my programming time on making Games and whatnot, simply because I didn't have the know-how in C++.

It's good that you're using other resources to teach yourself. One website the I used a lot was this. This may/may not help you, but It helped me a lot. It mostly helped me because After you read the chapter and learned from it, it gave you sample progarms to try, and full solutions. Also, it's a lot quicker than posting on CompSci, and I felt that I became a nussiance.

Not to knock on wtd. I mean, I don't know anyone else on CompSci that responds to any question faster than him. And very Detailed mite i add. He's without a doubt one of the most important mods here. Smile

But yeah, check out that site. You'll soon/may already be finishing it, but yeah. Good-Luck on it. Stick to it man, I'm comin back to it . . . later. . Wink
Author:  wtd [ Sun Jul 10, 2005 9:01 pm ]
Post subject: 
jamonathin wrote:
It's good that you're using other resources to teach yourself. One website the I used a lot was this. This may/may not help you, but It helped me a lot.


Unfortunately that resource is quite outdated.

c++:
#include <iostream.h>


c++:
int number;
char character;
       
for (number = 32 ; number <= 126 ; number = number + 1) {
   character = number;
   cout << "The character '" << character;
   cout << "' is represented as the number ";
   cout << number << " in the computer.\n";
}


As for this, it shows that the author doesn't know what you don't have to declare variables ahead of time in C++. It also demonstrates automatic conversion of integral data types, rather than the more sane explicit cast.

c++:
for (int number(32); number <= 126; number += 1)
{
   cout << "The character '" << static_cast<char>(number)
        << "' is represented as the number "
        << number << " in the computer." << endl;
}
Author:  wtd [ Sun Jul 10, 2005 9:04 pm ]
Post subject: 
Most horrifically that tutorial uses char arrays instead of proper strings. This is inexcusable.
Author:  jamonathin [ Sun Jul 10, 2005 9:11 pm ]
Post subject: 
wtd wrote:
This is inexcusable.


Snooty What was I thinking, lol. Ok ok, here's a better site. I mainly used taht site for programs. As in, "Ok, make <this> program", and so on . .
Author:  [Gandalf] [ Sun Jul 10, 2005 9:18 pm ]
Post subject: 
Well... Thanks for the explanation wtd, and the site jamonathin, although it might be out of date, I may be able to learn from it a bit, and it was an effort Smile.

All of that is just because it's old C++, right? Before they made the standard? That's why all the books and everythign I am learning from, I made sure it was all newer than 2002. They probably don't use typecasts right away because they want the person to understand the basics before going into more details.

Yep, I know what you mean jamonathin, I want to learn C++, but I also want to use graphics and the sort. One step at a time though. Still, I might make a game in Turing in between...

Oh, and wtd, do you know how to use colours in the standard console output? It's probably not that important, I know, but it would make the output more legible in larger amounts. Thanks for all the help.

*edit* Laughing yes, this site is the most helpful one out there. Especially with wtd here to help you out with your C++ needs.
Author:  wtd [ Sun Jul 10, 2005 9:27 pm ]
Post subject: 
[Gandalf] wrote:
Well... Thanks for the explanation wtd, and the site jamonathin, although it might be out of date, I may be able to learn from it a bit, and it was an effort Smile.


You'll have to unlearn most of what you learn from it.

[Gandalf] wrote:
All of that is just because it's old C++, right?


Some of it, probably, but there's also the fact that a lot of C programmers like to pretend that they know C++, just because of the syntactic similarities.


[Gandalf] wrote:
Oh, and wtd, do you know how to use colours in the standard console output? It's probably not that important, I know, but it would make the output more legible in larger amounts. Thanks for all the help.


Certainly no portable way. On Windows you could use the Win32 API to achieve this.

One post on the subject found by Google.
Author:  [Gandalf] [ Sun Jul 10, 2005 9:47 pm ]
Post subject: 
Too bad, at least it's possible...

Also, while looking at the source code for one of my favourite games, I saw that it uses printf(); even though it's coded in C++. Some of the books I am learning from use it, and other C-like functions as well. I think they might be a part of the 'standardized' library too. Why?
Author:  wtd [ Sun Jul 10, 2005 10:21 pm ]
Post subject: 
[Gandalf] wrote:
Too bad, at least it's possible...

Also, while looking at the source code for one of my favourite games, I saw that it uses printf(); even though it's coded in C++. Some of the books I am learning from use it, and other C-like functions as well. I think they might be a part of the 'standardized' library too. Why?


Backwards compatibility.

Windows XP will let you run apps written for the 16-bit Windows API. That doesn't mean you should write them. Smile
Author:  [Gandalf] [ Tue Jul 19, 2005 2:12 pm ]
Post subject: 
What are pointers for? I was looking at the very basics of them, and I think I understand how they work, but why use them? When you are say, showing a variable, why not show the actual thing instead of the pointer?
Author:  wtd [ Tue Jul 19, 2005 2:18 pm ]
Post subject: 
[Gandalf] wrote:
What are pointers for? I was looking at the very basics of them, and I think I understand how they work, but why use them?


A pointer is just a variable containing a number, which happens to be the location of some value in memory. This becomes incredibly valuable, primarily because your pointer can be null. It can refer to nothing.

A normal variable has to hold some kind of value. If you declare an integer, it has to hold a value. Even if that value is zero, it's still a value.

But a pointer that's zero, well that refers to nothing. Nad, zilch, squat. And, you can can determine if it is null or not at run-time.

[Gandalf] wrote:
When you are say, showing a variable, why not show the actual thing instead of the pointer?


Could you please post an exact example?
Author:  wtd [ Tue Jul 19, 2005 4:30 pm ]
Post subject: 
wtd wrote:
[Gandalf] wrote:
What are pointers for? I was looking at the very basics of them, and I think I understand how they work, but why use them?


A pointer is just a variable containing a number, which happens to be the location of some value in memory. This becomes incredibly valuable, primarily because your pointer can be null. It can refer to nothing.


It should be noted that this use of pointers becomes unnecessary ina language with support for variant types.

code:
data Maybe a = Just a | Nothing

indexOfValueInList :: a => Int ->a -> [a] -> Maybe Int
indexOfValueInList _ _ [] = Nothing
indexOfValueInList n val (x:xs)
  | val == x = Just n
  | otherwise = indexOfValueInList (n + 1) val xs

:


You can syndicate this boards posts using the file backend.php or view the topic map using sitemap.php.

Terms of Use | Privacy Policy