Cheat Engine :: View topic - C++ - How to get started?

Cheat Engine
The Official Site of Cheat Engine

FAQ

Memberlist

Usergroups

Profile

C++ - How to get started? - Thanks in Advance

Cheat Engine Forum Index -> General programming

View previous topic :: View next topic

Author

Message

AndrewMan
Grandmaster Cheater Supreme

Reputation: 0

Joined: 01 Aug 2007
Posts: 1257

Posted: Wed Jan 23, 2008 7:03 pm Post subject: C++ - How to get started? - Thanks in Advance

Alright guys. Lacrosse season starts in a month, so I got nothing to do till than. Im interested in learning C++, since it's just.. awesome? You get to make your own applications.. seriously. Ok anyways... Where Can I get started? Like, where do I download it? Is it just Microsoft Visual C++, and it's free right? If you have any sites to reccomend, this will all be appreciated. Thanks again! _________________ Every lvl up counts!

MUSTARD
Advanced Cheater

Reputation: 0

Joined: 26 Oct 2007
Posts: 56
Location: SPAM SECTION

Posted: Wed Jan 23, 2008 7:18 pm Post subject:

I am learning with Some Books C++ Primer Plus Learn in 21 Days. I also have ONE Website. cPlusPlus _________________

AndrewMan
Grandmaster Cheater Supreme

Reputation: 0

Joined: 01 Aug 2007
Posts: 1257

Posted: Wed Jan 23, 2008 7:27 pm Post subject:

MUSTARD wrote:

I am learning with Some Books

C++ Primer Plus

Learn in 21 Days.

I also have ONE Website.

cPlusPlus

Thanks so much for those sites!

Also, is DEV like the best c++ out there, besides visual c++?

Visual c++ takes like 15 hrs to install :S

I just DL'ed DEV.
_________________

Every lvl up counts!

lurc
Grandmaster Cheater Supreme

Reputation: 2

Joined: 13 Nov 2006
Posts: 1900

Posted: Wed Jan 23, 2008 7:36 pm Post subject:

i dont like Dev-Cpp, but thats my opinion. i just downloaded VS 2008, put it on a CD and installed it to my computer _________________

wunder312355
Grandmaster Cheater

Reputation: -1

Joined: 14 May 2007
Posts: 568

Posted: Wed Jan 23, 2008 8:12 pm Post subject:

This is the BesT place to start http://forum.cheatengine.org/viewtopic.php?t=187993 The videos are INCREDIBLE!

Spawnfestis
GO Moderator

Reputation: 0

Joined: 02 Nov 2007
Posts: 1746
Location: Pakistan

Posted: Mon Jan 28, 2008 6:49 am Post subject:

The best possible way to start is learning off a friend who are willing to help, doesn't have to be irl, just someone willing to help you with your errors and also being able to explain why it happened etc. You'll get to know C++ in just a few moments after doing some more complicated stuff, i don't generally recommend doing stuff which you don't understand. Do stuff you actually like, for instance a bot, a trainer, or something that helps you with what (i suppose) you do daily. Not some fucking calculator like i did, you don't get much out of it more than knowing the basics, and if you hack you already know the basics to begin with. Good luck =) _________________ CLICK TO HAX MAPLESTORAY ^ !!!!

Losplagos
Expert Cheater

Reputation: 0

Joined: 21 Mar 2006
Posts: 172
Location: Knee deep in a c++ book

Posted: Mon Jan 28, 2008 7:58 am Post subject:

MUSTARD wrote:

Learn in 21 Days.

I really like that book. It is nice to have around to go back too also.

Spawnfestis? might of spelled it wrong... wrote:

[color=0fff0122]The best possible way to start is learning off a friend who are willing to help, doesn't have to be irl, just someone willing to help you with your errors and also being able to explain why it happened etc.

You'll get to know C++ in just a few moments after doing some more complicated stuff, i don't generally recommend doing stuff which you don't understand.

Do stuff you actually like, for instance a bot, a trainer, or something that helps you with what (i suppose) you do daily.
Not some fucking calculator like i did, you don't get much out of it more than knowing the basics, and if you hack you already know the basics to begin with.

Good luck =)[/color]

You will never pickup a programing language in a few "moments". And generally you wont learn anything new if you dont try something you dont understand, but you should find resources / get help on something before you attempt it.
_________________

Earthbound = 31337

Spawnfestis
GO Moderator

Reputation: 0

Joined: 02 Nov 2007
Posts: 1746
Location: Pakistan

Posted: Mon Jan 28, 2008 8:23 am Post subject:

Losplagos wrote:

MUSTARD wrote:

Learn in 21 Days.

I really like that book. It is nice to have around to go back too also.

Spawnfestis? might of spelled it wrong... wrote:

I meant that he would understand the basics of it, and understand how it's built up.
_________________

CLICK TO HAX MAPLESTORAY ^ !!!!

Losplagos
Expert Cheater

Reputation: 0

Joined: 21 Mar 2006
Posts: 172
Location: Knee deep in a c++ book

Posted: Mon Jan 28, 2008 9:15 am Post subject:

Spawnfestis wrote:

I meant that he would understand the basics of it, and understand how it's built up.

The basics as in "commands" or functions already made from stuff like windows.h or iostream? Or the basics as in defining the memory addresses and making your own commands / functions? Basics depends all on what you need c++ would'nt be the best choice for programing a operating system, but if you needed to the basics would be very different from a windows program.

If your ever going to do more than program a few game cheats on a certain platform you will need to adapt. Even then you will need to constantly adapt to changes in game security.
If you ever consider getting a job programing expect that part of the code from that calculater program could be used in something else. Everything you do and learn in programing can be used for something else usually.

What im saying is everything can have another use. Also i am saying that you may learn that this takes these commands and you use it this way but that does'nt mean you will automaticly pickup exactly how it works.
_________________

Earthbound = 31337

appalsap
Moderator

Reputation: 0

Joined: 27 Apr 2006
Posts: 6753
Location: Pakistan

Posted: Mon Jan 28, 2008 9:20 am Post subject: Re: C++ - How to get started? - Thanks in Advance

AndrewMan wrote:

Alright guys. Lacrosse season starts in a month

Spawnfestis
GO Moderator

Reputation: 0

Joined: 02 Nov 2007
Posts: 1746
Location: Pakistan

Posted: Mon Jan 28, 2008 10:07 am Post subject:

Losplagos wrote:

Spawnfestis wrote:

I meant that he would understand the basics of it, and understand how it's built up.

Getting a job as a programmer is not (definately!) what he is looking for, he is obviously looking for a place to learn more in-depth hacking, else he wouldn't be posting in this forum really.
I respect the post of yours and i agree, but it has nothing to do with it.
Functions already made in headers are good to use, don't go against it.

Cheers.
_________________

CLICK TO HAX MAPLESTORAY ^ !!!!

Losplagos
Expert Cheater

Reputation: 0

Joined: 21 Mar 2006
Posts: 172
Location: Knee deep in a c++ book

Posted: Mon Jan 28, 2008 1:48 pm Post subject:

Spawnfestis wrote:

Losplagos wrote:

Spawnfestis wrote:

I meant that he would understand the basics of it, and understand how it's built up.

I do not have anything against using functions already made in headers. I meant to convey that when programing you will have to adapt, and that learning to make a calculater could help you with something completely different later on.

And when i asked about which basics i was preparing for the line saying that you may know this command does this by using it but will you know what it actually is doing in the code of that command.

And just for the heck of it istream and ostream ^_^

Code:

// Input streams -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

//
// ISO C++ 14882: 27.6.1 Input streams
//

/** @file istream
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the "st[dl]_*.h" implementation files.
*/

#ifndef _GLIBCXX_ISTREAM
#define _GLIBCXX_ISTREAM 1

#pragma GCC system_header

#include <ios>
#include <limits> // For numeric_limits

namespace std
{
// [27.6.1.1] Template class basic_istream
/**
* @brief Controlling input.
*
* This is the base class for all input streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual input.
*/
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;

// Non-standard Types:
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
 __num_get_type;
typedef ctype<_CharT> __ctype_type;

template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&);

template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

protected:
// Data Members:
/**
* @if maint
* The number of characters extracted in the previous unformatted
* function; see gcount().
* @endif
*/
streamsize _M_gcount;

public:
// [27.6.1.1.1] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes' initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_istream(__streambuf_type* __sb): _M_gcount(streamsize(0))
{ this->init(__sb); }

/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_istream()
{ _M_gcount = streamsize(0); }

// [27.6.1.1.2] prefix/suffix
class sentry;
friend class sentry;

// [27.6.1.2] formatted input
// [27.6.1.2.3] basic_istream::operator>>
//@{
/**
* @brief Interface for manipulators.
*
* Manuipulators such as @c std::ws and @c std::dec use these
* functions in constructs like "std::cin >> std::ws". For more
* information, see the iomanip header.
*/
inline __istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&));

inline __istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&));

inline __istream_type&
operator>>(ios_base& (*__pf)(ios_base&));
//@}

// [27.6.1.2.2] arithmetic extractors
/**
* @name Arithmetic Extractors
*
* All the @c operator>> functions (aka formatted input
* functions) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_istream::sentry
* with the second argument (noskipws) set to false. This has several
* effects, concluding with the setting of a status flag; see the
* sentry documentation for more.
*
* If the sentry status is good, the function tries to extract
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during extraction, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic extractors
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream's current locale (specifically, the
* @c num_get facet) to parse the input data.
*/
__istream_type&
operator>>(bool& __n);

__istream_type&
operator>>(short& __n);

__istream_type&
operator>>(unsigned short& __n);

__istream_type&
operator>>(int& __n);

__istream_type&
operator>>(unsigned int& __n);

__istream_type&
operator>>(long& __n);

__istream_type&
operator>>(unsigned long& __n);

#ifdef _GLIBCXX_USE_LONG_LONG
__istream_type&
operator>>(long long& __n);

__istream_type&
operator>>(unsigned long long& __n);
#endif

__istream_type&
operator>>(float& __f);

__istream_type&
operator>>(double& __f);

__istream_type&
operator>>(long double& __f);

__istream_type&
operator>>(void*& __p);

/**
* @brief Extracting into another streambuf.
* @param sb A pointer to a streambuf
*
* This function behaves like one of the basic arithmetic extractors,
* in that it also constructs a sentry object and has the same error
* handling behavior.
*
* If @a sb is NULL, the stream will set failbit in its error state.
*
* Characters are extracted from this stream and inserted into the
* @a sb streambuf until one of the following occurs:
*
* - the input stream reaches end-of-file,
* - insertion into the output buffer fails (in this case, the
* character that would have been inserted is not extracted), or
* - an exception occurs (and in this case is caught)
*
* If the function inserts no characters, failbit is set.
*/
__istream_type&
operator>>(__streambuf_type* __sb);
//@}

// [27.6.1.3] unformatted input
/**
* @brief Character counting
* @return The number of characters extracted by the previous
* unformatted input function dispatched for this stream.
*/
inline streamsize
gcount() const
{ return _M_gcount; }

/**
* @name Unformatted Input Functions
*
* All the unformatted input functions have some common behavior.
* Each starts by constructing a temporary object of type
* std::basic_istream::sentry with the second argument (noskipws)
* set to true. This has several effects, concluding with the
* setting of a status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to extract
* whatever data is appropriate for the type of the argument.
*
* The number of characters extracted is stored for later retrieval
* by gcount().
*
* If an exception is thrown during extraction, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Simple extraction.
* @return A character, or eof().
*
* Tries to extract a character. If none are available, sets failbit
* and returns traits::eof().
*/
int_type
get();

/**
* @brief Simple extraction.
* @param c The character in which to store data.
* @return *this
*
* Tries to extract a character and store it in @a c. If none are
* available, sets failbit and returns traits::eof().
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
get(char_type& __c);

/**
* @brief Simple multiple-character extraction.
* @param s Pointer to an array.
* @param n Maximum number of characters to store in @a s.
* @param delim A "stop" character.
* @return *this
*
* Characters are extracted and stored into @a s until one of the
* following happens:
*
* - @c n-1 characters are stored
* - the input sequence reaches EOF
* - the next character equals @a delim, in which case the character
* is not extracted
*
* If no characters are stored, failbit is set in the stream's error
* state.
*
* In any case, a null character is stored into the next location in
* the array.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);

/**
* @brief Simple multiple-character extraction.
* @param s Pointer to an array.
* @param n Maximum number of characters to store in @a s.
* @return *this
*
* Returns @c get(s,n,widen('\n')).
*/
inline __istream_type&
get(char_type* __s, streamsize __n)
{ return this->get(__s, __n, this->widen('\n')); }

/**
* @brief Extraction into another streambuf.
* @param sb A streambuf in which to store data.
* @param delim A "stop" character.
* @return *this
*
* Characters are extracted and inserted into @a sb until one of the
* following happens:
*
* - the input sequence reaches EOF
* - insertion into the output buffer fails (in this case, the
* character that would have been inserted is not extracted)
* - the next character equals @a delim (in this case, the character
* is not extracted)
* - an exception occurs (and in this case is caught)
*
* If no characters are stored, failbit is set in the stream's error
* state.
*/
__istream_type&
get(__streambuf_type& __sb, char_type __delim);

/**
* @brief Extraction into another streambuf.
* @param sb A streambuf in which to store data.
* @return *this
*
* Returns @c get(sb,widen('\n')).
*/
inline __istream_type&
get(__streambuf_type& __sb)
{ return this->get(__sb, this->widen('\n')); }

/**
* @brief String extraction.
* @param s A character array in which to store the data.
* @param n Maximum number of characters to extract.
* @param delim A "stop" character.
* @return *this
*
* Extracts and stores characters into @a s until one of the
* following happens. Note that these criteria are required to be
* tested in the order listed here, to allow an input line to exactly
* fill the @a s array without setting failbit.
*
* -# the input sequence reaches end-of-file, in which case eofbit
* is set in the stream error state
* -# the next character equals @c delim, in which case the character
* is extracted (and therefore counted in @c gcount()) but not stored
* -# @c n-1 characters are stored, in which case failbit is set
* in the stream error state
*
* If no characters are extracted, failbit is set. (An empty line of
* input should therefore not cause failbit to be set.)
*
* In any case, a null character is stored in the next location in
* the array.
*/
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);

/**
* @brief String extraction.
* @param s A character array in which to store the data.
* @param n Maximum number of characters to extract.
* @return *this
*
* Returns @c getline(s,n,widen('\n')).
*/
inline __istream_type&
getline(char_type* __s, streamsize __n)
{ return this->getline(__s, __n, this->widen('\n')); }

/**
* @brief Discarding characters
* @param n Number of characters to discard.
* @param delim A "stop" character.
* @return *this
*
* Extracts characters and throws them away until one of the
* following happens:
* - if @a n @c != @c std::numeric_limits<int>::max(), @a n
* characters are extracted
* - the input sequence reaches end-of-file
* - the next character equals @a delim (in this case, the character
* is extracted); note that this condition will never occur if
* @a delim equals @c traits::eof().
*/
__istream_type&
ignore(streamsize __n = 1, int_type __delim = traits_type::eof());

/**
* @brief Looking ahead in the stream
* @return The next character, or eof().
*
* If, after constructing the sentry object, @c good() is false,
* returns @c traits::eof(). Otherwise reads but does not extract
* the next input character.
*/
int_type
peek();

/**
* @brief Extraction without delimiters.
* @param s A character array.
* @param n Maximum number of characters to store.
* @return *this
*
* If the stream state is @c good(), extracts characters and stores
* them into @a s until one of the following happens:
* - @a n characters are stored
* - the input sequence reaches end-of-file, in which case the error
* state is set to @c failbit|eofbit.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
read(char_type* __s, streamsize __n);

/**
* @brief Extraction until the buffer is exhausted, but no more.
* @param s A character array.
* @param n Maximum number of characters to store.
* @return The number of characters extracted.
*
* Extracts characters and stores them into @a s depending on the
* number of characters remaining in the streambuf's buffer,
* @c rdbuf()->in_avail(), called @c A here:
* - if @c A @c == @c -1, sets eofbit and extracts no characters
* - if @c A @c == @c 0, extracts no characters
* - if @c A @c > @c 0, extracts @c min(A,n)
*
* The goal is to empty the current buffer, and to not request any
* more from the external input sequence controlled by the streambuf.
*/
streamsize
readsome(char_type* __s, streamsize __n);

/**
* @brief Unextracting a single character.
* @param c The character to push back into the input stream.
* @return *this
*
* If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c).
*
* If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in
* the error state.
*
* @note Since no characters are extracted, the next call to
* @c gcount() will return 0, as required by DR 60.
*/
__istream_type&
putback(char_type __c);

/**
* @brief Unextracting the previous character.
* @return *this
*
* If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c).
*
* If @c rdbuf() is null or if @c sungetc() fails, sets badbit in
* the error state.
*
* @note Since no characters are extracted, the next call to
* @c gcount() will return 0, as required by DR 60.
*/
__istream_type&
unget();

/**
* @brief Synchronizing the stream buffer.
* @return 0 on success, -1 on failure
*
* If @c rdbuf() is a null pointer, returns -1.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit and returns -1.
*
* Otherwise, returns 0.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
int
sync();

/**
* @brief Getting the current read position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in).
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
pos_type
tellg();

/**
* @brief Changing the current read position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
__istream_type&
seekg(pos_type);

/**
* @brief Changing the current read position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
__istream_type&
seekg(off_type, ios_base::seekdir);
//@}

protected:
explicit
basic_istream(): _M_gcount(streamsize(0)) { }
};

/**
* @brief Performs setup work for input streams.
*
* Objects of this class are created before all of the standard
* extractors are run. It is responsible for "exception-safe prefix and
* suffix operations," although only prefix actions are currently required
* by the standard. Additional actions may be added by the
* implementation, and we list them in
* http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/howto.html#5
* under [27.6] notes.
*/
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
public:
/// Easy access to dependant types.
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;

/**
* @brief The constructor performs all the work.
* @param is The input stream to guard.
* @param noskipws Whether to consume whitespace or not.
*
* If the stream state is good (@a is.good() is true), then the
* following actions are performed, otherwise the sentry state is
* false ("not okay") and failbit is set in the stream state.
*
* The sentry's preparatory actions are:
*
* -# if the stream is tied to an output stream, @c is.tie()->flush()
* is called to synchronize the output sequence
* -# if @a noskipws is false, and @c ios_base::skipws is set in
* @c is.flags(), the sentry extracts and discards whitespace
* characters from the stream. The currently imbued locale is
* used to determine whether each character is whitespace.
*
* If the stream state is still good, then the sentry state becomes
* true ("okay").
*/
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);

/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
operator bool() const { return _M_ok; }

private:
bool _M_ok;
};

// [27.6.1.2.3] character extraction templates
//@{
/**
* @brief Character extractors
* @param in An input stream.
* @param c A character reference.
* @return in
*
* Behaves like one of the formatted arithmetic extractors described in
* std::basic_istream. After constructing a sentry object with good
* status, this function extracts a character (if one is available) and
* stores it in @a c. Otherwise, sets failbit in the input stream.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }

template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
//@}

//@{
/**
* @brief Character string extractors
* @param in An input stream.
* @param s A pointer to a character array.
* @return in
*
* Behaves like one of the formatted arithmetic extractors described in
* std::basic_istream. After constructing a sentry object with good
* status, this function extracts up to @c n characters and stores them
* into the array starting at @a s. @c n is defined as:
*
* - if @c width() is greater than zero, @c n is width()
* - otherwise @c n is "the number of elements of the largest array of
* @c char_type that can store a terminating @c eos." [27.6.1.2.3]/6
*
* Characters are extracted and stored until one of the following happens:
* - @c n-1 characters are stored
* - EOF is reached
* - the next character is whitespace according to the current locale
* - the next character is a null byte (i.e., @c charT() )
*
* @c width(0) is then called for the input stream.
*
* If no characters are extracted, sets failbit.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);

template<class _Traits>
basic_istream<char,_Traits>&
operator>>(basic_istream<char,_Traits>& __in, unsigned char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }

template<class _Traits>
basic_istream<char,_Traits>&
operator>>(basic_istream<char,_Traits>& __in, signed char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
//@}

// 27.6.1.5 Template class basic_iostream
/**
* @brief Merging istream and ostream capabilities.
*
* This class multiply inherits from the input and output stream classes
* simply to provide a single interface.
*/
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 271. basic_iostream missing typedefs
// Types (inherited):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;

// Non-standard Types:
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;

/**
* @brief Constructor does nothing.
*
* Both of the parent classes are initialized with the same
* streambuf pointer passed to this constructor.
*/
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
: __istream_type(), __ostream_type()
{ this->init(__sb); }

/**
* @brief Destructor does nothing.
*/
virtual
~basic_iostream() { }

protected:
explicit
basic_iostream() : __istream_type(), __ostream_type()
{ }
};

// [27.6.1.4] standard basic_istream manipulators
/**
* @brief Quick and easy way to eat whitespace
*
* This manipulator extracts whitespace characters, stopping when the
* next character is non-whitespace, or when the input sequence is empty.
* If the sequence is empty, @c eofbit is set in the stream, but not
* @c failbit.
*
* The current locale is used to distinguish whitespace characters.
*
* Example:
* @code
* MyClass mc;
*
* std::cin >> std::ws >> mc;
* @endcode
* will skip leading whitespace before calling operator>> on cin and your
* object. Note that the same effect can be achieved by creating a
* std::basic_istream::sentry inside your definition of operator>>.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
} // namespace std

#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include <bits/istream.tcc>
#endif

#endif /* _GLIBCXX_ISTREAM */

Code:

// Output streams -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

//
// ISO C++ 14882: 27.6.2 Output streams
//

/** @file ostream
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the "st[dl]_*.h" implementation files.
*/

#ifndef _GLIBCXX_OSTREAM
#define _GLIBCXX_OSTREAM 1

#pragma GCC system_header

#include <ios>

namespace std
{
// [27.6.2.1] Template class basic_ostream
/**
* @brief Controlling output.
*
* This is the base class for all output streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual output.
*/
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;

// Non-standard Types:
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
 __num_put_type;
typedef ctype<_CharT> __ctype_type;

template<typename _CharT2, typename _Traits2>
friend basic_ostream<_CharT2, _Traits2>&
operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);

template<typename _Traits2>
friend basic_ostream<char, _Traits2>&
operator<<(basic_ostream<char, _Traits2>&, char);

template<typename _CharT2, typename _Traits2>
friend basic_ostream<_CharT2, _Traits2>&
operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);

template<typename _Traits2>
friend basic_ostream<char, _Traits2>&
operator<<(basic_ostream<char, _Traits2>&, const char*);

template<typename _CharT2, typename _Traits2>
friend basic_ostream<_CharT2, _Traits2>&
operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);

// [27.6.2.2] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes' initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }

/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_ostream() { }

// [27.6.2.3] prefix/suffix
class sentry;
friend class sentry;

// [27.6.2.5] formatted output
// [27.6.2.5.3] basic_ostream::operator<<
//@{
/**
* @brief Interface for manipulators.
*
* Manuipulators such as @c std::endl and @c std::hex use these
* functions in constructs like "std::cout << std::endl". For more
* information, see the iomanip header.
*/
inline __ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&));

inline __ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&));

inline __ostream_type&
operator<<(ios_base& (*__pf) (ios_base&));
//@}

// [27.6.2.5.2] arithmetic inserters
/**
* @name Arithmetic Inserters
*
* All the @c operator<< functions (aka formatted output
* functions) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_ostream::sentry.
* This can have several effects, concluding with the setting of a
* status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic inserters
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream's current locale (specifically, the
* @c num_get facet) to perform numeric formatting.
*/
__ostream_type&
operator<<(long __n);

__ostream_type&
operator<<(unsigned long __n);

__ostream_type&
operator<<(bool __n);

__ostream_type&
operator<<(short __n)
{
ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt & ios_base::oct || __fmt & ios_base::hex)
 return this->operator<<(static_cast<unsigned long>
 (static_cast<unsigned short>(__n)));
else
 return this->operator<<(static_cast<long>(__n));
}

__ostream_type&
operator<<(unsigned short __n)
{ return this->operator<<(static_cast<unsigned long>(__n)); }

__ostream_type&
operator<<(int __n)
{
ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt & ios_base::oct || __fmt & ios_base::hex)
 return this->operator<<(static_cast<unsigned long>
 (static_cast<unsigned int>(__n)));
else
 return this->operator<<(static_cast<long>(__n));
}

__ostream_type&
operator<<(unsigned int __n)
{ return this->operator<<(static_cast<unsigned long>(__n)); }

#ifdef _GLIBCXX_USE_LONG_LONG
__ostream_type&
operator<<(long long __n);

__ostream_type&
operator<<(unsigned long long __n);
#endif

__ostream_type&
operator<<(double __f);

__ostream_type&
operator<<(float __f)
{ return this->operator<<(static_cast<double>(__f)); }

__ostream_type&
operator<<(long double __f);

__ostream_type&
operator<<(const void* __p);

/**
* @brief Extracting from another streambuf.
* @param sb A pointer to a streambuf
*
* This function behaves like one of the basic arithmetic extractors,
* in that it also constructs a sentry object and has the same error
* handling behavior.
*
* If @a sb is NULL, the stream will set failbit in its error state.
*
* Characters are extracted from @a sb and inserted into @c *this
* until one of the following occurs:
*
* - the input stream reaches end-of-file,
* - insertion into the output sequence fails (in this case, the
* character that would have been inserted is not extracted), or
* - an exception occurs while getting a character from @a sb, which
* sets failbit in the error state
*
* If the function inserts no characters, failbit is set.
*/
__ostream_type&
operator<<(__streambuf_type* __sb);
//@}

// [27.6.2.6] unformatted output functions
/**
* @name Unformatted Output Functions
*
* All the unformatted output functions have some common behavior.
* Each starts by constructing a temporary object of type
* std::basic_ostream::sentry. This has several effects, concluding
* with the setting of a status flag; see the sentry documentation
* for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream's error state. If badbit is on in
* the stream's exceptions mask, the exception will be rethrown
* without completing its actions.
*/
//@{
/**
* @brief Simple insertion.
* @param c The character to insert.
* @return *this
*
* Tries to insert @a c.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
put(char_type __c);

// Core write functionality, without sentry.
void
_M_write(const char_type* __s, streamsize __n)
{
streamsize __put = this->rdbuf()->sputn(__s, __n);
if (__put != __n)
 this->setstate(ios_base::badbit);
}

/**
* @brief Character string insertion.
* @param s The array to insert.
* @param n Maximum number of characters to insert.
* @return *this
*
* Characters are copied from @a s and inserted into the stream until
* one of the following happens:
*
* - @a n characters are inserted
* - inserting into the output sequence fails (in this case, badbit
* will be set in the stream's error state)
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
write(const char_type* __s, streamsize __n);
//@}

/**
* @brief Synchronizing the stream buffer.
* @return *this
*
* If @c rdbuf() is a null pointer, changes nothing.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit.
*/
__ostream_type&
flush();

// [27.6.2.4] seek members
/**
* @brief Getting the current write position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
*/
pos_type
tellp();

/**
* @brief Changing the current write position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*/
__ostream_type&
seekp(pos_type);

/**
* @brief Changing the current write position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*/
__ostream_type&
seekp(off_type, ios_base::seekdir);

protected:
explicit
basic_ostream() { }
};

/**
* @brief Performs setup work for output streams.
*
* Objects of this class are created before all of the standard
* inserters are run. It is responsible for "exception-safe prefix and
* suffix operations." Additional actions may be added by the
* implementation, and we list them in
* http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/howto.html#5
* under [27.6] notes.
*/
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
// Data Members:
bool _M_ok;
basic_ostream<_CharT,_Traits>& _M_os;

public:
/**
* @brief The constructor performs preparatory work.
* @param os The output stream to guard.
*
* If the stream state is good (@a os.good() is true), then if the
* stream is tied to another output stream, @c is.tie()->flush()
* is called to synchronize the output sequences.
*
* If the stream state is still good, then the sentry state becomes
* true ("okay").
*/
explicit
sentry(basic_ostream<_CharT,_Traits>& __os);

/**
* @brief Possibly flushes the stream.
*
* If @c ios_base::unitbuf is set in @c os.flags(), and
* @c std::uncaught_exception() is true, the sentry destructor calls
* @c flush() on the output stream.
*/
~sentry()
{
// XXX MT
if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
 {
 // Can't call flush directly or else will get into recursive lock.
 if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
 _M_os.setstate(ios_base::badbit);
 }
}

/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
operator bool() const
{ return _M_ok; }
};

// [27.6.2.5.4] character insertion templates
//@{
/**
* @brief Character inserters
* @param out An output stream.
* @param c A character.
* @return out
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts a single character and any required
* padding (as determined by [22.2.2.2.2]). @c out.width(0) is then
* called.
*
* If @a c is of type @c char and the character type of the stream is not
* @c char, the character is widened before insertion.
*/
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);

template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
{ return (__out << __out.widen(__c)); }

// Specialization
template <class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c);

// Signed and unsigned
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
{ return (__out << static_cast<char>(__c)); }

template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
{ return (__out << static_cast<char>(__c)); }
//@}

//@{
/**
* @brief String inserters
* @param out An output stream.
* @param s A character string.
* @return out
* @pre @a s must be a non-NULL pointer
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts @c traits::length(s) characters starting
* at @a s, widened if necessary, followed by any required padding (as
* determined by [22.2.2.2.2]). @c out.width(0) is then called.
*/
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);

template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);

// Partial specializationss
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s);

// Signed and unsigned
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }

template<class _Traits>
basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
//@}

// [27.6.2.7] standard basic_ostream manipulators
/**
* @brief Write a newline and flush the stream.
*
* This manipulator is often mistakenly used when a simple newline is
* desired, leading to poor buffering performance. See
* http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 for more
* on this subject.
*/
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{ return flush(__os.put(__os.widen('\n'))); }

/**
* @brief Write a null character into the output sequence.
*
* "Null character" is @c CharT() by definition. For CharT of @c char,
* this correctly writes the ASCII @c NUL character string terminator.
*/
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
{ return __os.put(_CharT()); }

/**
* @brief Flushes the output stream.
*
* This manipulator simply calls the stream's @c flush() member function.
*/
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }

} // namespace std

#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include <bits/ostream.tcc>
#endif

#endif /* _GLIBCXX_OSTREAM */

Oh and iostream

Code:

// Standard iostream objects -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

//
// ISO C++ 14882: 27.3 Standard iostream objects
//

/** @file iostream
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the "st[dl]_*.h" implementation files.
*/

#ifndef _GLIBCXX_IOSTREAM
#define _GLIBCXX_IOSTREAM 1

#pragma GCC system_header

#include <bits/c++config.h>
#include <ostream>
#include <istream>

namespace std
{
/**
* @name Standard Stream Objects
*
* The <iostream> header declares the eight standard stream
* objects. For other declarations, see
* http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#10 and the
* @link s27_2_iosfwd I/O forward declarations @endlink
*
* They are required by default to cooperate with the global C library's
* @c FILE streams, and to be available during program startup and
* termination. For more information, see the HOWTO linked to above.
*/
//@{
extern istream cin; ///< Linked to standard input
extern ostream cout; ///< Linked to standard output
extern ostream cerr; ///< Linked to standard error (unbuffered)
extern ostream clog; ///< Linked to standard error (buffered)

#ifdef _GLIBCXX_USE_WCHAR_T
extern wistream wcin; ///< Linked to standard input
extern wostream wcout; ///< Linked to standard output
extern wostream wcerr; ///< Linked to standard error (unbuffered)
extern wostream wclog; ///< Linked to standard error (buffered)
#endif
//@}

// For construction of filebuffers for cout, cin, cerr, clog et. al.
static ios_base::Init __ioinit;
} // namespace std

#endif /* _GLIBCXX_IOSTREAM */

Very very complicated stuff. If you know how those work you can make any gamehack.
_________________

Earthbound = 31337

DotNet
Newbie cheater

Reputation: 0

Joined: 28 Jan 2008
Posts: 10

Posted: Mon Jan 28, 2008 2:03 pm Post subject:

lurc wrote:

i dont like Dev-Cpp, but thats my opinion.
i just downloaded VS 2008, put it on a CD and installed it to my computer Smile

can you send me a copy ?

hcavolsdsadgadsg
I'm a spammer

Reputation: 26

Joined: 11 Jun 2007
Posts: 5801

Posted: Mon Jan 28, 2008 2:32 pm Post subject:

Losplagos wrote:

Very very complicated stuff. If you know how those work you can make any gamehack.

what

Losplagos
Expert Cheater

Reputation: 0

Joined: 21 Mar 2006
Posts: 172
Location: Knee deep in a c++ book

Posted: Mon Jan 28, 2008 2:36 pm Post subject:

Im comparing it too something like.

Code:

#include <iostream>

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

Which is easy in comparison to most of your main headers you use like windows.h and iostream if you trace them down to the headers they use.
_________________

Earthbound = 31337

Display posts from previous:

	Cheat Engine Forum Index -> General programming	All times are GMT - 6 Hours
Page 1 of 1

Jump to:

You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum