|
25 Years of Programming
An open source source for C, C++, OWL, BASIC, MDB, XLS, DOT, and more... |
Home Projects Up Sitemap Search Blog Forum+Chat About Us Privacy Terms of Use Feedback FAQ Images Services Ads Donate Humor |
|
|
my.h header file for MS Visual C++ 2005When my programs #include "my.h", this is what is being included. It has an assortment of typedefs, #defines, prototypes for library functions, and some template functions. This version is for Microsoft Visual C++ Studio 2005 and its Standard Template Library (STL). The date on the first line of the listing is the "version number". Additions and revisions are being made fairly often during the process of converting the programs that use it to MSVC++. Most of my programs also require mylib.cpp. |
|
/* my.h 6-26-2008
MS Visual C++ 2005 Version.
Copyright (C)1994-2003, 2006-08 Steven Whitney.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
Version 3 as published by the Free Software Foundation.
This program 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 program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
------
Notes:
--This file is converted for VC++ use. It works, but some of it is probably unnecessary,
replaceable by new and better methods.
*/
#ifndef __MY_H
#define __MY_H
#include <cstring> // so that my library functions don't each need this line
#include <strstream> // for the userinput() template function
#include <fstream> // the rest are so commonly used, might as well include them.
#include <ostream>
#include <iostream>
#include <iomanip>
#include <time.h>
#include <stdio.h>
#include <vector>
#include <string>
#include <istream>
#define _USE_MATH_DEFINES
#include <math.h>
#include <io.h>
#include <ctype.h>
#include <ctime>
#include <stdlib.h>
#include <conio.h>
using namespace std;
using namespace System;
// turn off warnings about insecure strcpy() because the replacement fn strcpy_s() doesn't seem to work properly.
#pragma warning(disable:4996)
//////////////////////////////////////////////////////////////////////////////
typedef unsigned int uint;
typedef unsigned short ushort;
typedef unsigned long ulong;
typedef unsigned char uchar;
typedef signed char schar;
//////////////////////////////////////////////////////////////////////////////
// some macro definitions
//----------------------------------------------------------------------------
#define ERR (-1)
#define ON (1)
#define OFF (0)
#define YES (1)
#define NO (0)
//for compatibility with old Borland and OWL code
//it makes some trivial text replacements unnecessary, but it's lazy.
#define TRUE (true)
#define FALSE (false)
#define GetItemsInContainer() size()
typedef bool BOOL;
#define M_PI_180 0.0174532925199432951 // pi / 180
#define M_180_PI 57.2957795130823231 // 180 / pi
#define ROOT12OF2 1.05946309435929526 //12th root of 2, for music apps.
//these are leftover from Windows 3.1
//#define MAXUINT (0xFFFF) // max unsigned, 65535 (should be (uint)(-1) but check its uses first)
//#define MAXULONG (ulong)(-1) // largest possible ulong
//////////////////////////////////////////////////////////////////////////////
/* prototypes for my global library functions.
if a function has default parameters, specify them HERE because if you
call the function without the parameter, the compiler only has the
declaration here to refer to. It can't look ahead to the library module to
discover the default value there. Since it doesn't know there is a default
value, the missing parameter will generate an error.
Be sure to include my.h in all library function .cpp files so any
different or redeclared default values are caught.
*/
//----------------------------------------------------------------------------
void aborts(const string&); // abnormal termination, with message
const string& backupfile(const string& filename); // create a file, rename its old version to .bak
string bstring(const string& s); // output a string in brackets
int ci(); // console input
double cosine(double degrees); // cosine, with argument in degrees
uint countchr(const string& searchin, char lookforandcount); // count occurrences of a char in a string
string CRLFtoLF(const string& s); // change each CRLF to LF
string CRtoLF(const string& s); // change each CR to LF
int FontHeightInPixels(int pointsize); // Windows utility fn
double frand(); // random 0 to 1.0 (limit)
string& fromstring(string& var, const string& value); //overrides my template version, for for strings only
uint getpixel(double dx, double dy); // get color value of a pixel with x,y as doubles
uint gettoken(const string& source, size_t startpos, string& token); // extract token from text
uint gettoken(istream& is, string& token); // extract token from stream
uint getsentence(const string& source, size_t startpos, string& sentence); // extract a sentence from text
uint getsentence(istream& is, string& sentence); // extract a sentence from stream
void gputs(int x, int y, int color, char *text); // prints string to screen in DOS BGI graphics
void graborts(const string&); // aborts() from within DOS BGI graphics app
int initgraf(); // set up BGI graphics
bool isallspace(char *s); // if string contains all whitespace
bool isterminator(const string& token); // if it's a sentence-terminating token
string LFtoCR(const string& s); // change each LF to CR
string LFtoCRLF(const string& s); // insert a CR before each LF
uint logerror(string error = "", string filename = "error.log", bool beep = false); // log program error to a file
uint logtofile(const string& s, const string& filename); // send any string to a file
long lrandom(long top); // (long) random from 0 to top-1
int NormalRandom(double mean, double stddev); // normally distributed random number
int picload(const char *filename); // load a .PIC file
int picsave(const char *filename); // save a .PIC file
int presskey(ostream& os = cout); // says "Press any key to continue..."
string qstring(const string& s); // put a string in quotes
unsigned random(unsigned i); // random integer from 0 to i-1 (inclusive)
int round(double d); // round a double properly
uint sgetpixel(int x, int y); // ignores out of bounds requests
double similarity(const string& first, const string& second); // measures similarity of two strings
double sine(double degrees); // sine, with argument in degrees
bool strand(char *str, char *tofind, char dontcare = '?'); // performs an AND on two strings
bool strand(const string& searchin, const string& pattern, char dontcare = '?');
bool stringcontains(string& s, string& tofind); // true if s contains tofind
bool stringcontains(string& s, const char* tofind);
bool stringcontains(string& s, char tofind);
string& stringfromfile(string& s, ifstream& is); // append entire file contents to string s
void SystemStringToBasicString(String^ src, string& dest);//convert String to string
string& titlecase(string& s); // renders string in Title Case
string& tolower(string& s); // renders string in lower Case
string& toupper(string& s); // renders string in upper Case
string TranslateControls(const string& s); // replaces control chars in a string with ASCII mnemonics, e.g. <NUL>.
string unqstring(const string& s); // remove quotes from around a string
bool yesno(string prompt = "Continue", ostream& os = cout); // asks user a yes/no question
//////////////////////////////////////////////////////////////////////////////
//whole-degrees sine/cosine lookup tables, for speed
struct Trigtable
{
Trigtable(); //constructor
double cosines[360];
double sines[360];
};
//////////////////////////////////////////////////////////////////////////////
// TOSHIBA PRINTER FUNCTIONS
//----------------------------------------------------------------------------
#define TOSHIBADRAFT "\033*0"
#define TOSHIBAELITE "\033*1"
#define TOSHIBACOURIER "\033*2"
#define TOSHIBACONDENSE "\033["
#define TOSHIBABOLDON "\033K2"
#define TOSHIBABOLDOFF "\033M"
//////////////////////////////////////////////////////////////////////////////
/* CONSOLE APPLICATIONS ONLY
#error I have not yet found the test that distinguishes a console app
from a Windows Forms app. The distinction might no longer be necessary.
*/
//----------------------------------------------------------------------------
//#if !defined(__OWL_OWLCORE_H)
/* formerly userinpu.h 5-20-07
Variable input routines: prompts user, accepts input.
If user enters CR, current value for the variable is unchanged.
If user enters a value, variable is changed.
Luckily, this behavior is inherent in >> as used with cin (PG:213).
Don't call it input() because of possible conflicts, too general a name.
There are 2 versions because "only trivial type conversions are performed
with compiler-generated template functions" (PG:162).
Normally, you can pass a char array to a function requiring a string&, and
the compiler will do the conversion. In this case it won't, so you must
have the const char* version. The 2nd version is only useful where you
have a pre-constructed string that you want to pass, or you can cast the
prompt, as in: userinput(string("Enter something"),something);
which works but is cumbersome.
*/
//----------------------------------------------------------------------------
template<class T> void userinput(const char* prompt, T& defalt)
{
char temp[128] = { 0 };
cout << prompt << " <CR for " << defalt << ">: ";
cin.getline(temp,sizeof(temp)); // get new value, or a CR (empty)
if(strlen(temp))
istrstream(temp) >> defalt; // remember is >> string is buggy. see mystring.h
}
//----------------------------------------------------------------------------
template<class T> void userinput(const string& prompt, T& defalt)
{
userinput(prompt.c_str(),defalt);
}
//#endif //!defined(__OWL_OWLCORE_H)
//////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
/* signum function, 12-3-96
In this version, the returned value has the same type as the argument.
For some uses (such as switch()), you should cast the returned value to int.
*/
template<class T> T signum(const T& a)
{
return((a == (T)0) ? (T)0 : (a < (T)0) ? (T)(-1) : (T)1);
}
//----------------------------------------------------------------------------
/* swap two variables. class T must have a default constructor and an = operator.
this was previously called swap(), which conflicts with multimap::swap.
*/
template<class T> void swapvalues(T& a, T& b)
{
T temp;
temp = a;
a = b;
b = temp;
}
//////////////////////////////////////////////////////////////////////////////
/* 5-19-07
If a value falls outside the allowable range, bring it into the range. (no wrap)
Min and max are the lowest and highest values allowable, INCLUSIVE.
*/
template<class T> T range(T val, T min, T max)
{
if(min > max) // prevent mistakes
swapvalues(min,max);
if(val < min)
return min;
if(val > max)
return max;
return val;
}
//----------------------------------------------------------------------------
/* 6-30-99
wraparound. If a value falls outside the allowable range,
wrap it back into the range. Useful for screen wrap.
Only works properly for screen wrap for integral types (int, long).
See adapt.cpp for a specialized version for doubles.
Min and max are the lowest and highest values allowable, INCLUSIVE.
*/
template<class T> T wrap(T val, T min, T max)
{
if(min > max) // prevent runaway disaster
swap(min,max);
if(min == max) // not much you can do about this
return(min); // just return a legal value
T adj = max - min + (T)1;
while(val < min) val += adj;
while(val > max) val -= adj;
return(val);
}
//////////////////////////////////////////////////////////////////////////////
/* number to string 12-25-96
Create a string containing the text representation of a number.
Eliminates need for itoa() and similar functions and makes it easier to build
compound strings from both text and numeric pieces.
Example: string s = string("Number = ") + tostring(10) + " " + tostring(i);
Note it must return a string object, not a string&.
Template makes it applicable to any type numeric parameter, and
oddly, even any non-numeric object with an ostream << operator.
That's why the os is dynamic, just in case.
#error the MS VC++ compiler can't convert a (type) to a (type&)!!,
so this doesn't work anymore. However there is a .NET equivalent, ToString().
*/
//----------------------------------------------------------------------------
template<class T> string tostring(const T& t)
{
ostrstream os;
os << t << ends;
string s(os.str());
delete[] os.str();
return(s);
}
//////////////////////////////////////////////////////////////////////////////
/* fromstring 4-18-00
complementary function to tostring().
Allows you to assign to a variable the value encoded in a string.
Similar to Basica I = VAL(A$), and similar to atoi(), atod(), etc.,
or istream >> variable, but for STRINGS.
Works for any type for which read-from operator >> is defined, since it uses it.
But mystring.cpp has a special overriding version for strings.
*/
//----------------------------------------------------------------------------
template<class T> T& fromstring(T& var, const string& value)
{
// refuse to change ANY references or pointers, including char*
// refuse to change strings. they have a separate version in mystring.cpp.
// (I haven't tested this after adding the string exclusion here.)
string n = typeid(var).name();
if(n.contains("*") || n.contains("&") || n.contains("string"))
return(var);
char* s = new char[value.length() + 1];
strcpy(s,value.c_str());
istrstream(s) >> var;
delete[] s;
return(var);
} // fromstring
//////////////////////////////////////////////////////////////////////////////
/* allocate and delete 2-dimensional arrays of any type object. 5-17-97
the result is (height) arrays, each (width) wide.
----------------------------------------------------------------------------
needed because new int[a][b] is illegal. b must be a compile time constant.
if new fails, it will simply terminate the application, as xalloc always does.
adapted from PG:121. See also commented version in booksamp.cpp.
The unused T& argument is necessary so it knows what type a T is.
You can pass it any example of a "T" object.
----------------------------------------------------------------------------
it is dimensioned backwards as [y][x] because x should vary fastest when traversing
in scan-line fashion. Seems like it wouldn't matter if it were [x][y],
but don't change, because it is already in use.
----------------------------------------------------------------------------
When using with char arrays, don't try to load or write entire scan lines
at once, because each of the horizontal lines is not null-terminated.
*/
//----------------------------------------------------------------------------
template<class T> T** newarray2dim(const T&, int height, int width)
{
T** a = new T*[height];
for(int i = 0; i < height ; i++)
a[i] = new T[width];
return(a);
}
//----------------------------------------------------------------------------
template<class T> void deletearray2dim(T** a, int height)
{
for(int i = 0; i < height ; i++)
delete[] a[i];
delete[] a;
a = 0; // probably always want this, since it's an invalid pointer now, anyway
}
//////////////////////////////////////////////////////////////////////////////
/* csts() console status, for compatibility with DeSmet C.
It recognizes a function key as a keystroke, which kbhit() does not.
returns a (strangely encoded) non-zero value if keystroke waiting, zero if none.
If a keystroke is waiting, repeated csts() calls continue to return the SAME value
even if more keys are pressed. So if csts is nonzero, you should always
follow it with ci() to get whatever char is there.
Move to its own fn? if a key was pressed, get and return it, to flush.
*/
//----------------------------------------------------------------------------
#define csts() bioskey(_NKEYBRD_READY)
#endif // __MY_H DEFINED
|
|
|
|