|
I've tried several ideas and so far nothing seems to work. I'm simply trying to add some code to keep a console 32 program open. This is the release version of the program being opened from Windows Explorer. I've tried _getch(); and even a while(!getch());
ANy ideas?
tanks
|
|
|
|
|
_getch() always worked for me. You must be doing something wrong. Posting some code that "doesn't work" would help. (is my depth of perception increasing?)
// Afterall, I realized that even my comment lines have bugs
When one cannot invent, one must at least improve (in bed).-My latest fortune cookie
|
|
|
|
|
getch() usually does the trick. however, if there are any keys in the queue, it will see them, so you should use
while (kbhit()) getch();
getch();
"Der Geist des Kriegers ist erwacht / Ich hab die Macht" StS
sighist | Agile Programming | doxygen
|
|
|
|
|
I don't think so Toni...
Thanks Pete,will try
|
|
|
|
|
One important question: What happens when you are in the debugger? Does it make it to the _getch() statement?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~<br />
Peter Weyzen<br />
Staff Engineer<br />
Santa Cruz Networks
|
|
|
|
|
|
Thanks Pete,
I finally got it to work.
|
|
|
|
|
DaveE9th wrote:
I don't think so Toni...
Well, I am not the one having troubles with a getch() statement, that even the kids in my neighborhood know how to use it by now. You have posted this question so many times that one would think that you are dealing with the problem of the century. Read some books first.
// Afterall, I realized that even my comment lines have bugs
When one cannot invent, one must at least improve (in bed).-My latest fortune cookie
|
|
|
|
|
hello @all,
i need a something, that find the maximum of different int or double values.
for example:
max{1, 2.5, 2}=2.5
can anybody help me?
thank you very much.
sunny
|
|
|
|
|
use a macro like
#define max(a, b) (a > b ? a : b)
or if you need a variable ammount of arguments, create a function that uses va_list, like this one (MSDN example)
|
|
|
|
|
just two notes
a) you shouldn't use a macro if it can be expressed in the language - i.e.
template <typename T> inline T max(T a, T b) { return (a > b) ? a : b; } should do it without side effect problems, correct name scoping
b) if you need to use a macro, use braces around each argument,
#define max(a,b) ((a) > (b) ? (a) : (b))
"Der Geist des Kriegers ist erwacht / Ich hab die Macht" StS
sighist | Agile Programming | doxygen
|
|
|
|
|
Use macro is not a good choice.You can find this in <<effective c++="">> Item 1 :
#define max(a,b) ((a) > (b) ? (a) : (b))
This little number has so many drawbacks, just thinking about them is painful. You're better off playing in the freeway during rush hour.
Whenever you write a macro like this, you have to remember to parenthesize all the arguments when you write the macro body; otherwise you can run into trouble when somebody calls the macro with an expression. But even if you get that right, look at the weird things that can happen:
int a = 5, b = 0;
max(++a, b); // a is incremented twice
max(++a, b+10); // a is incremented once
Here, what happens to a inside max depends on what it is being compared with!
|
|
|
|
|
I know of that -
That's what's commonly called "side effects" (I was referring to in my post) - that's why (mostly9 the first instruction never to use macros unless you cannot do without 
"Der Geist des Kriegers ist erwacht / Ich hab die Macht" StS
sighist | Agile Programming | doxygen
|
|
|
|
|
I really haven't tested this code to check for errors but this is the general idea on how to get the maximum number:
int nNoNumbers = SOME_VALUE;
int *piArrayNums = new int[ nNoNumbers ];
...
...
int iMax = piArrayNums[ 0 ];
for( i = 0; i < nNoNumbers; i++ )
{
if( piArrayNums[ i ] > iMax )
{
iMax = piArrayNums[ i ];
}
}
The same thing can be done with doubles.
// Afterall, I realized that even my comment lines have bugs
When one cannot invent, one must at least improve (in bed).-My latest fortune cookie
|
|
|
|
|
|
hello @all,
i need a dynamic two-dimensional matrix. how can i do this?
thank you very much!
sunny
|
|
|
|
|
You can use malloc and realloc to do it all yourself, or use a STL vector or vectors.
Neville Franks, Author of ED for Windows. Free Trial at www.getsoft.com
|
|
|
|
|
if you just need 2d array that doesnt shrink or grow frequently then you can use two approaches, pointers to pointers or a 1d array accessed by formula.
for pointers to pointers this is how it's done:
int ** p;
p = new int * [10];
for(int i = 0; i <10; i++)
p[i] = new int[10];
for(int i = 0; i < 10; i++)
for(int j = 0; j < 10; j++)
p[i][j] = rand();
for(int i = 0; i <10; i++)
delete [] p[i];
delete [] p;
for 1d arrays, you make an array with size m * n and access elements at i,j by formula j * m + i, where m are rows and n are columns.
int * p = new int[m * n];
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
p[j * m + i] = rand();
delete [] p;
this approach is better since the whole array elements are compact together rather than having group of 1d arrays scattered in the memory.
if you need an array that grows and shrink frequently, then you may use template containers to make array or arrays, rather than making your own class for it.
for example, if you gonna use the STL vector container you can declare the array as follows:
vector< vector<int> > my_matrix;
my_matrix.resize(10);
for(int i = 0; i <10; i++)
my_matrix[i].resize(10);
for(i = 0; i < 10; i++)
for(int j = 0; j < 10; j++)
my_matrix[i][j] = rand();
this also can be done using the MFC's CArray using the declaration
CArray< CArray<int, int>, CArray<int, int> > my_matrix;
|
|
|
|
|
MAAK wrote:
this approach is better since the whole array elements are compact together rather than having group of 1d arrays scattered in the memory.
Does it really matter if they are scattered in the memory? My impression was quite different because the elements of the array will be accessed through indirect addressing and the general formula is [ base reg + factor *index reg + constant ]. I don't see a large overhead in computing the index. I am really opened to suggestions because I am geting very curios now.
// Afterall, I realized that even my comment lines have bugs
When one cannot invent, one must at least improve (in bed).-My latest fortune cookie
|
|
|
|
|
For people who develop high-end software.... like spreadsheets and data models. This makes a huge difference. There's all kinds of fancy algorithms to make a true dynamic and fast array.
For this case, it probably doesn't....
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~<br />
Peter Weyzen<br />
Staff Engineer<br />
Santa Cruz Networks
|
|
|
|
|
That is very interesting. Thank you very much Peter for your reply.
// Afterall, I realized that even my comment lines have bugs
When one cannot invent, one must at least improve (in bed).-My latest fortune cookie
|
|
|
|
|
I've had more than one programming job in the past working for companies that developed spreadsheets. They used a pretty fancy algorithm, based on something called "sparse matrix arrays" [You can search on the net for that, and you'll find all kinds of sites, with people posting and discussing these algorithms.]
It was all about letting you create a spreadsheet with a virtual array of large proportions, and making it both quick to access entries in the array, and make it occupy as little memory as possible.
Excel does a virtual array of 64K rows, 255 columns, and a third dimension of page accesses -- a 3D sparse array... with a possible capcity of 4,261,413,375 array entries (cells).
There's no way you can pre-allocate an array of that size... But the arrays do allow you to place data anywhere, and it works and it remains small and fast.
People get paid a lot of money to develop data structures like these... too bad it wasn't me.
-p
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~<br />
Peter Weyzen<br />
Staff Engineer<br />
Santa Cruz Networks
|
|
|
|
|
Well I think I didn't think about it correctly, cuz when I think about it again I found that the int ** seems to have better performance than the 1D array implemenation, and it may be not related to how data is near to each other.
The int ** needs 4 mov micro instruction to get the effective address, while the 1D needs 2 mov, one multiplication (which I think more costy and which make the whole overhead) and one addition operation to get the effective address.
This is the assembly code for getting the effective address in the 1D implementation for a matrix 10 x 10 to access element (i, j)
ar[j * w + i] = 5;
mov eax,dword ptr [j]
imul eax,dword ptr [w]
add eax,dword ptr [i]
mov ecx,dword ptr [ar]
mov dword ptr [ecx+eax*4],5
This is code for the int ** implementation for a matrix 10 x 10
ar[i][j] = 5;
mov eax,dword ptr [i]
mov ecx,dword ptr [ar]
mov edx,dword ptr [ecx+eax*4]
mov eax,dword ptr [j]
mov dword ptr [edx+eax*4],5
however, I found that the the 1D representation is more commonly used for example, this is how the same thing work for a static 2D array declared in the compiler:
ar[i][j] = 5;
mov eax,dword ptr [i]
imul eax,eax,28h
lea ecx,ar[eax]
mov edx,dword ptr [j]
mov dword ptr [ecx+edx*4],5
If you checked it thourougly you will find that it's similar to the 1D, but it has optimization due to previous knowledge of the array size.
[All assembly code is obtained using VC++ debugging disassembly]
This approach is useful in data serializzation since serialization can be done using single call to I/O device, bitmaps for example are stored in memory as a single 1D array.
I hope if anyone has more infomation about this issue shares it with us, cuz am more curios about it.
|
|
|
|
|
W. Richard Stevens:
Advanced Programming in the UNIX(R) Environment(my price:$30, amazon's price:$69.99)
UNIX Network Programming Volume1 2nd Ed.(my price:$30, amazon's price:$69.93)
UNIX Network Programming Volume 2 : (my price:$30, amazon's price:$66)
TCP/IP Illustrated, Volume 1:(my price:$30, amazon's price:$69.99)
TCP/IP Illustrated, Volume 2:(my price:$35, amazon's price:$69.99)
TCP/IP Illustrated, Volume 3:(my price:$30, amazon's price:$54.99)
volume 1-3(my price:$85)
Bjarne Stroustrup:
The c++ programming Language(Special Edition)(my price:$32, amazon's price:$64.99)
The Design and Evolution of c++ (my price:$20, amazon's price:$44.99)
scott meyers:
effective c++(my price:$20, amazon's price:$37.95)
effective STL(my price:$25, amazon's price:$39.99)
Andrei Alexandrescu:
Modern C++ Design(my price:$20, amazon's price:$42.99)
Brian w.Kernighan:
The Practice of Programming(my price:$20, amazon's price:$26.99)
Erich Gamma:
Design Patterns(my price:$25, amazon's price:$54.99)
Alan Shalloway:
Design Patterns Explained(my price:$25, amazon's price:$39.99)
Martin Fowler:
Refactoring(my price:$27, amazon's price:$49.99)
All of these are new.Some books are not list,if you are
interested in them,please send me an E-mail.(chester163@hotmail.com)
code,code,code...
chester163@hotmail.com
|
|
|
|
|
SPAMMER
Neville Franks, Author of ED for Windows. Free Trial at www.getsoft.com
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
