Hi!
Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically, the
majority (>65%) of the bytes in the grid equal 0 meaning that they are not
used. My goal is to be able to:
a) QUICKLY search for non-zero bytes that fall within a particular range
of the grid. For instance: Find all non-zero bytes that fall between
500(x),100(y) and 2000(xx),3000(yy)...ie within a rectangle.
b) Be able to change the values of bytes within the grid at any time
using an x,y coordinate...speed is not as critical here.
I'm using a byte[4192, 4192] at the moment but is that the fastest approach?
It seems like a waste to iterate through every byte within a portion of the
grid when most of the bytes typically equal 0 and won't be used for
anything. Should I store only the non-zero bytes in some sort of collection
instead to speed things up? If I do that, what's the best one to use in
order to be able to access the items with an x,y coordinate system as
quickly as possible?
The bottom line is that I'm using this byte data to do some form painting
(which is already painfully slow because it's GDI+)...so I'm looking to
speed up any other areas of my painting code that I can.
TIA!
-sb
6  1363 
"sb" <st********@yahoo.com> wrote: Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically, the
majority (>65%) of the bytes in the grid equal 0 meaning that they are not
used. My goal is to be able to:
a) QUICKLY search for non-zero bytes that fall within a particular range
of the grid.
Ideas:
(1) Storing 1 bit per pixel means your grid takes up 2Mbytes, which
can be searched pretty quickly in a plain unimaginative way.
(2) You should tell us for what reason you're looking for non-zero
bytes, i.e. what you're doing with this information upstream. I say
this because there might be cunning BitBlt/raster-op tricks you can
use which avoid the need to search for individual pixels. Also, 3d
graphics hardware does zillions of per-pixel tests per frame, so you
might be able to phrase your problem cunningly as a 3d rendering
problem and get the video card to solve it for free.
(3) A wacky far-out idea, good if there are few enough pixels, might
be to store the grid as a BDD (binary-decision-diagram). The standard
library for these is called "Buddy" but I don't know if it has a C#
port. You'd store the state of the grid as a BDD proposition. 4192 is
made up of 12 binary bits, so each pixel coordinate is a predicate on
24 binary bits. Then the BDD proposition
state & (x1=true & x2=false & ... & x12=true & y1=...)
represents the previous state of the grid, but with this extra pixel
turned on.
To check if a range contains any non-zero bytes, represent your query
as a similar predicate on booleans, and perform a boolean "AND"
operation on the current state, and just read off the answer.
BDDs are an enormous area of research because of all their practical
applications, so by using them you could leverage all that work for
free! What BDDs are doing, effectively, is they're automatically
dividing up your hierarchy so that large empty spaces are stored
efficiently. Kind of like JPEG. You might try to invent your own
similar hierarchical/sparse representation, but I think the odds are
about 50/50 that you'd come up with something more efficient than
BDDs.
--
Lucian
A little more info:
(1) I need all 8 bits of data for grid location in order to determine what
to paint.
(2) My app basically allows the user to zoom in/out on an image. I take the
byte and use it to determine what color pixel to draw on screen when the
user is zoomed out fully. When the user zooms in, I actually paint
thumbnail images instead based on this value....anyway there are 255
possible images. None of this is configurable btw...it's an editor for a
game that already exists and which I have no control over unfortunately.
(3) I will do some research on BDDs...I'm not familiar with them and they
sound interesting.
A couple related questions:
1) Is there a faster way to draw individual pixels on screen other than
using Graphics.DrawLine?
2) Is there a faster way to scale & copy a bitmap to the screen?
I have no problems using Win32 calls if it will make a noticable
difference...GDI+ is so sloooooooowww. I heard it doesn't take advantage of
any hardware acceleration (yet) so I'm guessing that's why it drags. Also
note that I tried using DirextX but it ended up being too complicated for
doing simple 2D work...especially since DirectDraw is now deprecated which
forces everyone to use Direct3D calls...blecht. Why should I have to create
two triangles everytime I want to draw a single bitmap?!? :)
Thanks for the response :)
-sb
"Lucian Wischik" <lu***@wischik.com> wrote in message
news:jo********************************@4ax.com... "sb" <st********@yahoo.com> wrote:Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically,
the
majority (>65%) of the bytes in the grid equal 0 meaning that they are not
used. My goal is to be able to:
a) QUICKLY search for non-zero bytes that fall within a particular
range
of the grid.
Ideas:
(1) Storing 1 bit per pixel means your grid takes up 2Mbytes, which
can be searched pretty quickly in a plain unimaginative way.
(2) You should tell us for what reason you're looking for non-zero
bytes, i.e. what you're doing with this information upstream. I say
this because there might be cunning BitBlt/raster-op tricks you can
use which avoid the need to search for individual pixels. Also, 3d
graphics hardware does zillions of per-pixel tests per frame, so you
might be able to phrase your problem cunningly as a 3d rendering
problem and get the video card to solve it for free.
(3) A wacky far-out idea, good if there are few enough pixels, might
be to store the grid as a BDD (binary-decision-diagram). The standard
library for these is called "Buddy" but I don't know if it has a C#
port. You'd store the state of the grid as a BDD proposition. 4192 is
made up of 12 binary bits, so each pixel coordinate is a predicate on
24 binary bits. Then the BDD proposition
state & (x1=true & x2=false & ... & x12=true & y1=...)
represents the previous state of the grid, but with this extra pixel
turned on.
To check if a range contains any non-zero bytes, represent your query
as a similar predicate on booleans, and perform a boolean "AND"
operation on the current state, and just read off the answer.
BDDs are an enormous area of research because of all their practical
applications, so by using them you could leverage all that work for
free! What BDDs are doing, effectively, is they're automatically
dividing up your hierarchy so that large empty spaces are stored
efficiently. Kind of like JPEG. You might try to invent your own
similar hierarchical/sparse representation, but I think the odds are
about 50/50 that you'd come up with something more efficient than
BDDs.
--
Lucian
Hi,
about point (2): you should take a look at DirectX which, by hardware, or
by software if the hardware cannot, could find the correct "minimap" to
use, dependant of the zoom. You can also use DX in a window, not necessary
in full screen.
You have also some control on the "interpolation" technique you wish to use
(DirectX will call it "filtering") which cover case where the source (say
16*16 pixels) has more points than the destination (4*4) or less point than
the destination (256*256). And again, if possible, it uses the hardware
rather than the software, if possible. On the other hand, how to do it, with
details, exceed the context of a newsgroup message.
Vanderghast, Access MVP
"sb" <st********@yahoo.com> wrote in message
news:eX**************@TK2MSFTNGP05.phx.gbl... A little more info:
(1) I need all 8 bits of data for grid location in order to determine what
to paint.
(2) My app basically allows the user to zoom in/out on an image. I take
the byte and use it to determine what color pixel to draw on screen when
the user is zoomed out fully. When the user zooms in, I actually paint
thumbnail images instead based on this value....anyway there are 255
possible images. None of this is configurable btw...it's an editor for a
game that already exists and which I have no control over unfortunately.
(3) I will do some research on BDDs...I'm not familiar with them and they
sound interesting.
A couple related questions:
1) Is there a faster way to draw individual pixels on screen other than
using Graphics.DrawLine?
2) Is there a faster way to scale & copy a bitmap to the screen?
I have no problems using Win32 calls if it will make a noticable
difference...GDI+ is so sloooooooowww. I heard it doesn't take advantage
of any hardware acceleration (yet) so I'm guessing that's why it drags.
Also note that I tried using DirextX but it ended up being too complicated
for doing simple 2D work...especially since DirectDraw is now deprecated
which forces everyone to use Direct3D calls...blecht. Why should I have
to create two triangles everytime I want to draw a single bitmap?!? :)
Thanks for the response :)
-sb
"Lucian Wischik" <lu***@wischik.com> wrote in message
news:jo********************************@4ax.com... "sb" <st********@yahoo.com> wrote:Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically,
the
majority (>65%) of the bytes in the grid equal 0 meaning that they are
not
used. My goal is to be able to:
a) QUICKLY search for non-zero bytes that fall within a particular
range
of the grid.
Ideas:
(1) Storing 1 bit per pixel means your grid takes up 2Mbytes, which
can be searched pretty quickly in a plain unimaginative way.
(2) You should tell us for what reason you're looking for non-zero
bytes, i.e. what you're doing with this information upstream. I say
this because there might be cunning BitBlt/raster-op tricks you can
use which avoid the need to search for individual pixels. Also, 3d
graphics hardware does zillions of per-pixel tests per frame, so you
might be able to phrase your problem cunningly as a 3d rendering
problem and get the video card to solve it for free.
(3) A wacky far-out idea, good if there are few enough pixels, might
be to store the grid as a BDD (binary-decision-diagram). The standard
library for these is called "Buddy" but I don't know if it has a C#
port. You'd store the state of the grid as a BDD proposition. 4192 is
made up of 12 binary bits, so each pixel coordinate is a predicate on
24 binary bits. Then the BDD proposition
state & (x1=true & x2=false & ... & x12=true & y1=...)
represents the previous state of the grid, but with this extra pixel
turned on.
To check if a range contains any non-zero bytes, represent your query
as a similar predicate on booleans, and perform a boolean "AND"
operation on the current state, and just read off the answer.
BDDs are an enormous area of research because of all their practical
applications, so by using them you could leverage all that work for
free! What BDDs are doing, effectively, is they're automatically
dividing up your hierarchy so that large empty spaces are stored
efficiently. Kind of like JPEG. You might try to invent your own
similar hierarchical/sparse representation, but I think the odds are
about 50/50 that you'd come up with something more efficient than
BDDs.
--
Lucian
In addition, DirectX is vector-based graphics, which means that scaling is
fast and easy.
--
HTH,
Kevin Spencer
Microsoft MVP
Professional Numbskull
Hard work is a medication for which
there is no placebo.
"Michel Walsh" <vanderghast@VirusAreFunnierThanSpam> wrote in message
news:%2****************@TK2MSFTNGP05.phx.gbl... Hi,
about point (2): you should take a look at DirectX which, by hardware, or
by software if the hardware cannot, could find the correct "minimap" to
use, dependant of the zoom. You can also use DX in a window, not necessary
in full screen.
You have also some control on the "interpolation" technique you wish to
use (DirectX will call it "filtering") which cover case where the source
(say 16*16 pixels) has more points than the destination (4*4) or less
point than the destination (256*256). And again, if possible, it uses the
hardware rather than the software, if possible. On the other hand, how to
do it, with details, exceed the context of a newsgroup message.
Vanderghast, Access MVP
"sb" <st********@yahoo.com> wrote in message
news:eX**************@TK2MSFTNGP05.phx.gbl...A little more info:
(1) I need all 8 bits of data for grid location in order to determine
what to paint.
(2) My app basically allows the user to zoom in/out on an image. I take
the byte and use it to determine what color pixel to draw on screen when
the user is zoomed out fully. When the user zooms in, I actually paint
thumbnail images instead based on this value....anyway there are 255
possible images. None of this is configurable btw...it's an editor for a
game that already exists and which I have no control over unfortunately.
(3) I will do some research on BDDs...I'm not familiar with them and they
sound interesting.
A couple related questions:
1) Is there a faster way to draw individual pixels on screen other than
using Graphics.DrawLine?
2) Is there a faster way to scale & copy a bitmap to the screen?
I have no problems using Win32 calls if it will make a noticable
difference...GDI+ is so sloooooooowww. I heard it doesn't take advantage
of any hardware acceleration (yet) so I'm guessing that's why it drags.
Also note that I tried using DirextX but it ended up being too
complicated for doing simple 2D work...especially since DirectDraw is now
deprecated which forces everyone to use Direct3D calls...blecht. Why
should I have to create two triangles everytime I want to draw a single
bitmap?!? :)
Thanks for the response :)
-sb
"Lucian Wischik" <lu***@wischik.com> wrote in message
news:jo********************************@4ax.com... "sb" <st********@yahoo.com> wrote:
Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically,
the
majority (>65%) of the bytes in the grid equal 0 meaning that they are
not
used. My goal is to be able to:
a) QUICKLY search for non-zero bytes that fall within a particular
range
of the grid.
Ideas:
(1) Storing 1 bit per pixel means your grid takes up 2Mbytes, which
can be searched pretty quickly in a plain unimaginative way.
(2) You should tell us for what reason you're looking for non-zero
bytes, i.e. what you're doing with this information upstream. I say
this because there might be cunning BitBlt/raster-op tricks you can
use which avoid the need to search for individual pixels. Also, 3d
graphics hardware does zillions of per-pixel tests per frame, so you
might be able to phrase your problem cunningly as a 3d rendering
problem and get the video card to solve it for free.
(3) A wacky far-out idea, good if there are few enough pixels, might
be to store the grid as a BDD (binary-decision-diagram). The standard
library for these is called "Buddy" but I don't know if it has a C#
port. You'd store the state of the grid as a BDD proposition. 4192 is
made up of 12 binary bits, so each pixel coordinate is a predicate on
24 binary bits. Then the BDD proposition
state & (x1=true & x2=false & ... & x12=true & y1=...)
represents the previous state of the grid, but with this extra pixel
turned on.
To check if a range contains any non-zero bytes, represent your query
as a similar predicate on booleans, and perform a boolean "AND"
operation on the current state, and just read off the answer.
BDDs are an enormous area of research because of all their practical
applications, so by using them you could leverage all that work for
free! What BDDs are doing, effectively, is they're automatically
dividing up your hierarchy so that large empty spaces are stored
efficiently. Kind of like JPEG. You might try to invent your own
similar hierarchical/sparse representation, but I think the odds are
about 50/50 that you'd come up with something more efficient than
BDDs.
--
Lucian
Hi,
Very true, but not only vector based. As example, an interesting part of it
is about texture (bit maps), how a texture is applied, how it interacts
(with other applied textures, to create transparency, light, or shadow), how
it can even move, ... and in fact, I was thinking about using the scene as
made of a single texture in my first message, and as you zoom in and out,
you see smaller part or larger part of it, inside a fixed window. A possible
solution implies just changing the texture coordinates of the four corners
of the window: (0, 0) in top-left (1, 1) in bot-right, you see the whole
bitmap; while (.25, .25) and (.75, .75), you see only 1/4 of it (1/2
horizontally, 1/2 vertically), which plays the role of zooming in. No camera
movement involved. And, in the end, it is handled by the Graphical
Processing Unit, GPU, generally much faster than using the CPU...
Vanderghast, Access MVP
"Kevin Spencer" <ke***@DIESPAMMERSDIEtakempis.com> wrote in message
news:er**************@TK2MSFTNGP05.phx.gbl... In addition, DirectX is vector-based graphics, which means that scaling is
fast and easy.
--
HTH,
Kevin Spencer
Microsoft MVP
Professional Numbskull
Hard work is a medication for which
there is no placebo.
"Michel Walsh" <vanderghast@VirusAreFunnierThanSpam> wrote in message
news:%2****************@TK2MSFTNGP05.phx.gbl... Hi,
about point (2): you should take a look at DirectX which, by hardware,
or by software if the hardware cannot, could find the correct "minimap"
to use, dependant of the zoom. You can also use DX in a window, not
necessary in full screen.
You have also some control on the "interpolation" technique you wish to
use (DirectX will call it "filtering") which cover case where the source
(say 16*16 pixels) has more points than the destination (4*4) or less
point than the destination (256*256). And again, if possible, it uses the
hardware rather than the software, if possible. On the other hand, how to
do it, with details, exceed the context of a newsgroup message.
Vanderghast, Access MVP
"sb" <st********@yahoo.com> wrote in message
news:eX**************@TK2MSFTNGP05.phx.gbl...A little more info:
(1) I need all 8 bits of data for grid location in order to determine
what to paint.
(2) My app basically allows the user to zoom in/out on an image. I take
the byte and use it to determine what color pixel to draw on screen when
the user is zoomed out fully. When the user zooms in, I actually paint
thumbnail images instead based on this value....anyway there are 255
possible images. None of this is configurable btw...it's an editor for
a game that already exists and which I have no control over
unfortunately.
(3) I will do some research on BDDs...I'm not familiar with them and
they sound interesting.
A couple related questions:
1) Is there a faster way to draw individual pixels on screen other than
using Graphics.DrawLine?
2) Is there a faster way to scale & copy a bitmap to the screen?
I have no problems using Win32 calls if it will make a noticable
difference...GDI+ is so sloooooooowww. I heard it doesn't take
advantage of any hardware acceleration (yet) so I'm guessing that's why
it drags. Also note that I tried using DirextX but it ended up being too
complicated for doing simple 2D work...especially since DirectDraw is
now deprecated which forces everyone to use Direct3D calls...blecht.
Why should I have to create two triangles everytime I want to draw a
single bitmap?!? :)
Thanks for the response :)
-sb
"Lucian Wischik" <lu***@wischik.com> wrote in message
news:jo********************************@4ax.com...
"sb" <st********@yahoo.com> wrote:
>Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically,
>the
>majority (>65%) of the bytes in the grid equal 0 meaning that they are
>not
>used. My goal is to be able to:
> a) QUICKLY search for non-zero bytes that fall within a particular
> range
>of the grid.
Ideas:
(1) Storing 1 bit per pixel means your grid takes up 2Mbytes, which
can be searched pretty quickly in a plain unimaginative way.
(2) You should tell us for what reason you're looking for non-zero
bytes, i.e. what you're doing with this information upstream. I say
this because there might be cunning BitBlt/raster-op tricks you can
use which avoid the need to search for individual pixels. Also, 3d
graphics hardware does zillions of per-pixel tests per frame, so you
might be able to phrase your problem cunningly as a 3d rendering
problem and get the video card to solve it for free.
(3) A wacky far-out idea, good if there are few enough pixels, might
be to store the grid as a BDD (binary-decision-diagram). The standard
library for these is called "Buddy" but I don't know if it has a C#
port. You'd store the state of the grid as a BDD proposition. 4192 is
made up of 12 binary bits, so each pixel coordinate is a predicate on
24 binary bits. Then the BDD proposition
state & (x1=true & x2=false & ... & x12=true & y1=...)
represents the previous state of the grid, but with this extra pixel
turned on.
To check if a range contains any non-zero bytes, represent your query
as a similar predicate on booleans, and perform a boolean "AND"
operation on the current state, and just read off the answer.
BDDs are an enormous area of research because of all their practical
applications, so by using them you could leverage all that work for
free! What BDDs are doing, effectively, is they're automatically
dividing up your hierarchy so that large empty spaces are stored
efficiently. Kind of like JPEG. You might try to invent your own
similar hierarchical/sparse representation, but I think the odds are
about 50/50 that you'd come up with something more efficient than
BDDs.
--
Lucian
I did a mock up a while ago in DirectX and it the code 20 times more
complex. Just maintaining a valid device in an MDI application (ie multiple
DX windows) is enough to give anyone a headache. Tying in a DirectX window
seamlessly with normal Windows interface controls is no easy task either.
IMHO Microsoft is severely hurting the 2D developers by dropping support for
DirectDraw. I suppose they believe that everyone using DirectX will be
working on 3D games nowadays so support for 2D developers is no longer
important to them.
Anyway, I know that DirectX will do this much faster...but the tradeoff in
code complexity isn't worth it for me just yet.
-sb
"Michel Walsh" <vanderghast@VirusAreFunnierThanSpam> wrote in message
news:%2****************@TK2MSFTNGP05.phx.gbl... Hi,
about point (2): you should take a look at DirectX which, by hardware, or
by software if the hardware cannot, could find the correct "minimap" to
use, dependant of the zoom. You can also use DX in a window, not necessary
in full screen.
You have also some control on the "interpolation" technique you wish to
use (DirectX will call it "filtering") which cover case where the source
(say 16*16 pixels) has more points than the destination (4*4) or less
point than the destination (256*256). And again, if possible, it uses the
hardware rather than the software, if possible. On the other hand, how to
do it, with details, exceed the context of a newsgroup message.
Vanderghast, Access MVP
"sb" <st********@yahoo.com> wrote in message
news:eX**************@TK2MSFTNGP05.phx.gbl...A little more info:
(1) I need all 8 bits of data for grid location in order to determine
what to paint.
(2) My app basically allows the user to zoom in/out on an image. I take
the byte and use it to determine what color pixel to draw on screen when
the user is zoomed out fully. When the user zooms in, I actually paint
thumbnail images instead based on this value....anyway there are 255
possible images. None of this is configurable btw...it's an editor for a
game that already exists and which I have no control over unfortunately.
(3) I will do some research on BDDs...I'm not familiar with them and they
sound interesting.
A couple related questions:
1) Is there a faster way to draw individual pixels on screen other than
using Graphics.DrawLine?
2) Is there a faster way to scale & copy a bitmap to the screen?
I have no problems using Win32 calls if it will make a noticable
difference...GDI+ is so sloooooooowww. I heard it doesn't take advantage
of any hardware acceleration (yet) so I'm guessing that's why it drags.
Also note that I tried using DirextX but it ended up being too
complicated for doing simple 2D work...especially since DirectDraw is now
deprecated which forces everyone to use Direct3D calls...blecht. Why
should I have to create two triangles everytime I want to draw a single
bitmap?!? :)
Thanks for the response :)
-sb
"Lucian Wischik" <lu***@wischik.com> wrote in message
news:jo********************************@4ax.com... "sb" <st********@yahoo.com> wrote:
Imagine a grid that is 4192 bytes wide and 4192 bytes high. Typically,
the
majority (>65%) of the bytes in the grid equal 0 meaning that they are
not
used. My goal is to be able to:
a) QUICKLY search for non-zero bytes that fall within a particular
range
of the grid.
Ideas:
(1) Storing 1 bit per pixel means your grid takes up 2Mbytes, which
can be searched pretty quickly in a plain unimaginative way.
(2) You should tell us for what reason you're looking for non-zero
bytes, i.e. what you're doing with this information upstream. I say
this because there might be cunning BitBlt/raster-op tricks you can
use which avoid the need to search for individual pixels. Also, 3d
graphics hardware does zillions of per-pixel tests per frame, so you
might be able to phrase your problem cunningly as a 3d rendering
problem and get the video card to solve it for free.
(3) A wacky far-out idea, good if there are few enough pixels, might
be to store the grid as a BDD (binary-decision-diagram). The standard
library for these is called "Buddy" but I don't know if it has a C#
port. You'd store the state of the grid as a BDD proposition. 4192 is
made up of 12 binary bits, so each pixel coordinate is a predicate on
24 binary bits. Then the BDD proposition
state & (x1=true & x2=false & ... & x12=true & y1=...)
represents the previous state of the grid, but with this extra pixel
turned on.
To check if a range contains any non-zero bytes, represent your query
as a similar predicate on booleans, and perform a boolean "AND"
operation on the current state, and just read off the answer.
BDDs are an enormous area of research because of all their practical
applications, so by using them you could leverage all that work for
free! What BDDs are doing, effectively, is they're automatically
dividing up your hierarchy so that large empty spaces are stored
efficiently. Kind of like JPEG. You might try to invent your own
similar hierarchical/sparse representation, but I think the odds are
about 50/50 that you'd come up with something more efficient than
BDDs.
--
Lucian
This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics
by: Randell D. |
last post by:
Folks,
I have a Javascript performance question that I might have problems
explaining...
In PHP, better performance can be obtained dealing directly with a
variable, as opposed to an element...
|
by: Mark Shelor |
last post by:
I've encountered a troublesome inconsistency in the C-language Perl
extension I've written for CPAN (Digest::SHA). The problem involves the
use of a static array within a performance-critical...
|
by: Martin |
last post by:
I am using graphics as backgrounds for forms,buttons,labels etc.
The question is: is it faster to load all graphics from files on app start
or
to use it embeded (places in editor during design)....
|
by: bjarne |
last post by:
Willy Denoyette wrote;
> ... it
> was not the intention of StrousTrup to the achieve the level of efficiency
> of C when he invented C++, ...
Ahmmm. It was my aim to match the performance...
|
by: Mike |
last post by:
Lets just say my app is done HOO HOO.
Now, I'm accessing the database via a web service and one thing i noticed
that my app is running real slow. When I first started working on the app is
ran...
|
by: Rune B |
last post by:
Hi Group
I was considering using a Generic Dictionary<> as a value container inside
my business objects, for the reason of keeping track of fields changed or
added and so on.
- But how...
|
by: Varangian |
last post by:
Hi,
I have a performance issue question?
which is best (in terms of efficiency and performance, I don't care
neatness in code)... building an ArrayList of Object Instances using
SqlDataReader...
|
by: Markus Ernst |
last post by:
Hello
A class that composes the output of shop-related data gets some info
from the main shop class. Now I wonder whether it is faster to store the
info in the output class or get it from the...
|
by: toton |
last post by:
Hi,
I want a few of my class to overload from a base class, where the
base class contains common functionality. This is to avoid repetition
of code, and may be reducing amount of code in binary,...
|
by: galiorenye |
last post by:
Hi,
Given this code:
A** ppA = new A*;
A *pA = NULL;
for(int i = 0; i < 10; ++i)
{
pA = ppA;
//do something with pA
|
by: Charles Arthur |
last post by:
How do i turn on java script on a villaon, callus and itel keypad mobile phone
|
by: ryjfgjl |
last post by:
If we have dozens or hundreds of excel to import into the database, if we use the excel import function provided by database editors such as navicat, it will be extremely tedious and time-consuming...
|
by: ryjfgjl |
last post by:
In our work, we often receive Excel tables with data in the same format. If we want to analyze these data, it can be difficult to analyze them because the data is spread across multiple Excel files...
|
by: BarryA |
last post by:
What are the essential steps and strategies outlined in the Data Structures and Algorithms (DSA) roadmap for aspiring data scientists? How can individuals effectively utilize this roadmap to progress...
|
by: nemocccc |
last post by:
hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?
|
by: Sonnysonu |
last post by:
This is the data of csv file
1 2 3
1 2 3
1 2 3
1 2 3
2 3
2 3
3
the lengths should be different i have to store the data by column-wise with in the specific length.
suppose the i have to...
|
by: Hystou |
last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can...
|
by: jinu1996 |
last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows...
| |
