end() operation 
Author Message
 end() operation

Hi,

Can anyone help me explain why the two lines of the
following code are not same?

vector<Date> e;
...
e.insert( --e.end(), TodaysDate() ); <-- illegal
e.insert( e.end() -1, TodaysDate() ); <-- legal

Why does --e.end() will modify temporaries of Date*, while
e.end()-1 can execute?

Thanks in advance,

Andy



Tue, 28 Dec 2004 00:22:03 GMT  
 end() operation
vector::end returns an rvalue, but -- operator needs an
lvalue. --e.end() does not work for the same reason for which

e.end() = e.begin();

does not work.
--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken


Quote:
> Hi,

> Can anyone help me explain why the two lines of the
> following code are not same?

> vector<Date> e;
> ...
> e.insert( --e.end(), TodaysDate() ); <-- illegal
> e.insert( e.end() -1, TodaysDate() ); <-- legal

> Why does --e.end() will modify temporaries of Date*, while
> e.end()-1 can execute?

> Thanks in advance,

> Andy



Tue, 28 Dec 2004 00:40:21 GMT  
 end() operation
Igor,

I guess rvalue means const variable. But the following
code doesn't work as well. Can you explain?

Date* f();
p = --f();

Thanks,

Andy

Quote:
>-----Original Message-----
>vector::end returns an rvalue, but -- operator needs an
>lvalue. --e.end() does not work for the same reason for
which

>e.end() = e.begin();

>does not work.
>--
>With best wishes,
>    Igor Tandetnik

>"For every complex problem, there is a solution that is
simple, neat,
>and wrong." H.L. Mencken



>> Hi,

>> Can anyone help me explain why the two lines of the
>> following code are not same?

>> vector<Date> e;
>> ...
>> e.insert( --e.end(), TodaysDate() ); <-- illegal
>> e.insert( e.end() -1, TodaysDate() ); <-- legal

>> Why does --e.end() will modify temporaries of Date*,
while
>> e.end()-1 can execute?

>> Thanks in advance,

>> Andy

>.



Tue, 28 Dec 2004 00:53:45 GMT  
 end() operation

Quote:

> Can anyone help me explain why the two lines of the
> following code are not same?

> vector<Date> e;
> ...
> e.insert( --e.end(), TodaysDate() ); <-- illegal
> e.insert( e.end() -1, TodaysDate() ); <-- legal

> Why does --e.end() will modify temporaries of Date*, while
> e.end()-1 can execute?

Um, because --e.end() attempts to modify e.end() and e.end() - 1 does
not?

--<x> will decrement x and return the result.
<x>-1 will subtract 1 from x (without changing x) and return the result.



Tue, 28 Dec 2004 00:54:40 GMT  
 end() operation
lvalue is, roughly speaking, something that can occur on the left side
of assignment. rvalue is any expression that is not an lvalue.

To be legal on the left side of an assignment, the expression must refer
to a memory location. Suppose you have (int x) variable. Then (x) refers
to a memory location occupied by x variable and thus you can write (x =
10). But (x + 1) does not refer to any memory location, thus you cannot
write (x + 1 = 10).

A return value of a function is not an lvalue unless it returns a
reference:

int global;
int f1() {return global;}
int* f2() {return &global;}
int& f3() {return global;}

// Illegal. f1 returns a copy of global.
// Said copy does not occupy any particular memory location
f1() = 1;

// Legal. f2 returns a pointer to global. This pointer, when
dereferenced,
// refers to a particular memory location occupied by global.
*f2() = 2;

// Also legal. Very similar to case 2, only the syntax is maybe somewhat
cleaner.
// f3 directly returns a reference to memory occupied by global.
f3() = 3;

Now, the -- operator is supposed to get the value of expression,
decrement it, and put the value back. --exp is essentially the same as
(exp = exp - 1). Thus, an lvalue is required.
--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken


Quote:
> Igor,

> I guess rvalue means const variable. But the following
> code doesn't work as well. Can you explain?

> Date* f();
> p = --f();

> Thanks,

> Andy
> >-----Original Message-----
> >vector::end returns an rvalue, but -- operator needs an
> >lvalue. --e.end() does not work for the same reason for
> which

> >e.end() = e.begin();

> >does not work.
> >--
> >With best wishes,
> >    Igor Tandetnik

> >"For every complex problem, there is a solution that is
> simple, neat,
> >and wrong." H.L. Mencken



> >> Hi,

> >> Can anyone help me explain why the two lines of the
> >> following code are not same?

> >> vector<Date> e;
> >> ...
> >> e.insert( --e.end(), TodaysDate() ); <-- illegal
> >> e.insert( e.end() -1, TodaysDate() ); <-- legal

> >> Why does --e.end() will modify temporaries of Date*,
> while
> >> e.end()-1 can execute?

> >> Thanks in advance,

> >> Andy

> >.



Tue, 28 Dec 2004 01:01:07 GMT  
 end() operation
Hi Igor,

Thanks you for your excellent explanation!

Can I say that if a function doesn't return a reference,
it will return an anonymous temp variable, which is like a
const variable?

Regards,

Andy

Quote:
>-----Original Message-----
>lvalue is, roughly speaking, something that can occur on
the left side
>of assignment. rvalue is any expression that is not an
lvalue.

>To be legal on the left side of an assignment, the

expression must refer
Quote:
>to a memory location. Suppose you have (int x) variable.
Then (x) refers
>to a memory location occupied by x variable and thus you
can write (x =
>10). But (x + 1) does not refer to any memory location,
thus you cannot
>write (x + 1 = 10).

>A return value of a function is not an lvalue unless it
returns a
>reference:

>int global;
>int f1() {return global;}
>int* f2() {return &global;}
>int& f3() {return global;}

>// Illegal. f1 returns a copy of global.
>// Said copy does not occupy any particular memory
location
>f1() = 1;

>// Legal. f2 returns a pointer to global. This pointer,
when
>dereferenced,
>// refers to a particular memory location occupied by
global.
>*f2() = 2;

>// Also legal. Very similar to case 2, only the syntax is
maybe somewhat
>cleaner.
>// f3 directly returns a reference to memory occupied by
global.
>f3() = 3;

>Now, the -- operator is supposed to get the value of
expression,
>decrement it, and put the value back. --exp is

essentially the same as

- Show quoted text -

Quote:
>(exp = exp - 1). Thus, an lvalue is required.
>--
>With best wishes,
>    Igor Tandetnik

>"For every complex problem, there is a solution that is
simple, neat,
>and wrong." H.L. Mencken



>> Igor,

>> I guess rvalue means const variable. But the following
>> code doesn't work as well. Can you explain?

>> Date* f();
>> p = --f();

>> Thanks,

>> Andy
>> >-----Original Message-----
>> >vector::end returns an rvalue, but -- operator needs an
>> >lvalue. --e.end() does not work for the same reason for
>> which

>> >e.end() = e.begin();

>> >does not work.
>> >--
>> >With best wishes,
>> >    Igor Tandetnik

>> >"For every complex problem, there is a solution that is
>> simple, neat,
>> >and wrong." H.L. Mencken



>> >> Hi,

>> >> Can anyone help me explain why the two lines of the
>> >> following code are not same?

>> >> vector<Date> e;
>> >> ...
>> >> e.insert( --e.end(), TodaysDate() ); <-- illegal
>> >> e.insert( e.end() -1, TodaysDate() ); <-- legal

>> >> Why does --e.end() will modify temporaries of Date*,
>> while
>> >> e.end()-1 can execute?

>> >> Thanks in advance,

>> >> Andy

>> >.

>.



Tue, 28 Dec 2004 02:20:54 GMT  
 end() operation

Quote:

>Hi,

>Can anyone help me explain why the two lines of the
>following code are not same?

>vector<Date> e;
>...
>e.insert( --e.end(), TodaysDate() ); <-- illegal
>e.insert( e.end() -1, TodaysDate() ); <-- legal

>Why does --e.end() will modify temporaries of Date*, while
>e.end()-1 can execute?

>Thanks in advance,

You're using the VC6 vector, whose iterators are plain pointers. The
expression e.end() returns a pointer, which is not modifiable, as it's
a temporary object of a non-class type, so the compiler rejects
--e.end(). In VC7, it would work, because its vector::iterator is a
class type, its operator-- is a member function, and you can call
member functions on temporaries of class type. In general, that's a
good thing, as it's sometimes convenient to say things like X().y().

The error message talks about lvalues, but these are both rvalues. The
whole concept has become rather blurred in C++. On the other hand,
e.end()-1 doesn't modify anything, and the subtraction operator can
use constants or temporaries. It only requires rvalues.

Bonus points to anyone who can explain the following:

#include <vector>

void g(std::vector<int>::iterator&);

void f(std::vector<int>& x)
{
   g(x.end()); // Illegal.
   g(--x.end()); // Fine in VC7!

Quote:
}

--
Doug Harrison
Microsoft MVP - Visual C++
Eluent Software, LLC
http://www.eluent.com
Tools for VC++, VS.NET, and Windows


Tue, 28 Dec 2004 02:25:11 GMT  
 end() operation
So, the function return value is an "anonymance" const
variable, which cannot be referred to?

Hope this time I am right.

Thanks,

Andy

Quote:
>-----Original Message-----
>There is still a difference. You can take address of a
const variable,
>resulting in a pointer to const. You cannot assign though
this pointer,
>but you can, for example, print the address of the
variable and get a
>real memory location. But you cannot take address of an
rvalue - it does
>not have one.
>--
>With best wishes,
>    Igor Tandetnik

>"For every complex problem, there is a solution that is
simple, neat,
>and wrong." H.L. Mencken



>> Hi Igor,

>> Thanks you for your excellent explanation!

>> Can I say that if a function doesn't return a reference,
>> it will return an anonymous temp variable, which is
like a
>> const variable?

>> Regards,

>> Andy

>> >-----Original Message-----
>> >lvalue is, roughly speaking, something that can occur
on
>> the left side
>> >of assignment. rvalue is any expression that is not an
>> lvalue.

>> >To be legal on the left side of an assignment, the
>> expression must refer
>> >to a memory location. Suppose you have (int x)
variable.
>> Then (x) refers
>> >to a memory location occupied by x variable and thus
you
>> can write (x =
>> >10). But (x + 1) does not refer to any memory location,
>> thus you cannot
>> >write (x + 1 = 10).

>> >A return value of a function is not an lvalue unless it
>> returns a
>> >reference:

>> >int global;
>> >int f1() {return global;}
>> >int* f2() {return &global;}
>> >int& f3() {return global;}

>> >// Illegal. f1 returns a copy of global.
>> >// Said copy does not occupy any particular memory
>> location
>> >f1() = 1;

>> >// Legal. f2 returns a pointer to global. This pointer,
>> when
>> >dereferenced,
>> >// refers to a particular memory location occupied by
>> global.
>> >*f2() = 2;

>> >// Also legal. Very similar to case 2, only the syntax
is
>> maybe somewhat
>> >cleaner.
>> >// f3 directly returns a reference to memory occupied
by
>> global.
>> >f3() = 3;

>> >Now, the -- operator is supposed to get the value of
>> expression,
>> >decrement it, and put the value back. --exp is
>> essentially the same as
>> >(exp = exp - 1). Thus, an lvalue is required.
>> >--
>> >With best wishes,
>> >    Igor Tandetnik

>> >"For every complex problem, there is a solution that is
>> simple, neat,
>> >and wrong." H.L. Mencken



>> >> Igor,

>> >> I guess rvalue means const variable. But the
following
>> >> code doesn't work as well. Can you explain?

>> >> Date* f();
>> >> p = --f();

>> >> Thanks,

>> >> Andy
>> >> >-----Original Message-----
>> >> >vector::end returns an rvalue, but -- operator
needs an
>> >> >lvalue. --e.end() does not work for the same reason
for
>> >> which

>> >> >e.end() = e.begin();

>> >> >does not work.
>> >> >--
>> >> >With best wishes,
>> >> >    Igor Tandetnik

>> >> >"For every complex problem, there is a solution
that is
>> >> simple, neat,
>> >> >and wrong." H.L. Mencken



>> >> >> Hi,

>> >> >> Can anyone help me explain why the two lines of
the
>{ w?  
> W  ?VL??    > >> >> following code are not same?

>> >> >> vector<Date> e;
>> >> >> ...
>> >> >> e.insert( --e.end(), TodaysDate() ); <-- illegal
>> >> >> e.insert( e.end() -1, TodaysDate() ); <-- legal

>> >> >> Why does --e.end() will modify temporaries of
Date*,
>> >> while



Tue, 28 Dec 2004 03:15:45 GMT  
 end() operation
There is still a difference. You can take address of a const variable,
resulting in a pointer to const. You cannot assign though this pointer,
but you can, for example, print the address of the variable and get a
real memory location. But you cannot take address of an rvalue - it does
not have one.
--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken


Quote:
> Hi Igor,

> Thanks you for your excellent explanation!

> Can I say that if a function doesn't return a reference,
> it will return an anonymous temp variable, which is like a
> const variable?

> Regards,

> Andy

> >-----Original Message-----
> >lvalue is, roughly speaking, something that can occur on
> the left side
> >of assignment. rvalue is any expression that is not an
> lvalue.

> >To be legal on the left side of an assignment, the
> expression must refer
> >to a memory location. Suppose you have (int x) variable.
> Then (x) refers
> >to a memory location occupied by x variable and thus you
> can write (x =
> >10). But (x + 1) does not refer to any memory location,
> thus you cannot
> >write (x + 1 = 10).

> >A return value of a function is not an lvalue unless it
> returns a
> >reference:

> >int global;
> >int f1() {return global;}
> >int* f2() {return &global;}
> >int& f3() {return global;}

> >// Illegal. f1 returns a copy of global.
> >// Said copy does not occupy any particular memory
> location
> >f1() = 1;

> >// Legal. f2 returns a pointer to global. This pointer,
> when
> >dereferenced,
> >// refers to a particular memory location occupied by
> global.
> >*f2() = 2;

> >// Also legal. Very similar to case 2, only the syntax is
> maybe somewhat
> >cleaner.
> >// f3 directly returns a reference to memory occupied by
> global.
> >f3() = 3;

> >Now, the -- operator is supposed to get the value of
> expression,
> >decrement it, and put the value back. --exp is
> essentially the same as
> >(exp = exp - 1). Thus, an lvalue is required.
> >--
> >With best wishes,
> >    Igor Tandetnik

> >"For every complex problem, there is a solution that is
> simple, neat,
> >and wrong." H.L. Mencken



> >> Igor,

> >> I guess rvalue means const variable. But the following
> >> code doesn't work as well. Can you explain?

> >> Date* f();
> >> p = --f();

> >> Thanks,

> >> Andy
> >> >-----Original Message-----
> >> >vector::end returns an rvalue, but -- operator needs an
> >> >lvalue. --e.end() does not work for the same reason for
> >> which

> >> >e.end() = e.begin();

> >> >does not work.
> >> >--
> >> >With best wishes,
> >> >    Igor Tandetnik

> >> >"For every complex problem, there is a solution that is
> >> simple, neat,
> >> >and wrong." H.L. Mencken



> >> >> Hi,

> >> >> Can anyone help me explain why the two lines of the
> >> >> following code are not same?

> >> >> vector<Date> e;
> >> >> ...
> >> >> e.insert( --e.end(), TodaysDate() ); <-- illegal
> >> >> e.insert( e.end() -1, TodaysDate() ); <-- legal

> >> >> Why does --e.end() will modify temporaries of Date*,
> >> while
> >> >> e.end()-1 can execute?

> >> >> Thanks in advance,

> >> >> Andy

> >> >.

> >.



Tue, 28 Dec 2004 03:04:19 GMT  
 end() operation
I believe Scott Meyers explains the reasons, and it goes something like
this. --x.end() is actually

x.end().operator--();

operator-- returns iterator&. Now, the compiler knows for sure that
x.end() returns a temporary, and temporaries cannot be bound to
non-const references. But the compiler cannot deduce that operator--
still returns a temporary - it could, potentially, return a reference to
some global variable or something. No way to tell at compile time. So
the result loses its temporary status, and can happily bind to a
reference.

It boils down to something like this:

class X
{
public:
    X& Detemporize() {return *this;}

Quote:
};

X tempX() {return X();}
void bindX(X&);

bindX(tempX()); // shouldn't work
bindX(tempX().Detemporize()); // should work

BTW, for some reason both calls compile under VC6 SP5. Is this a bug?
--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken



Quote:
> Bonus points to anyone who can explain the following:

> #include <vector>

> void g(std::vector<int>::iterator&);

> void f(std::vector<int>& x)
> {
>    g(x.end()); // Illegal.
>    g(--x.end()); // Fine in VC7!
> }



Tue, 28 Dec 2004 03:14:26 GMT  
 end() operation
Hi,

My explanation is the e.end() is not a valid iterator.
Thus, std::vector<int>::iterator& cannot refers to it.

Regards,

Andy

Quote:
>-----Original Message-----

>>Hi,

>>Can anyone help me explain why the two lines of the
>>following code are not same?

>>vector<Date> e;
>>...
>>e.insert( --e.end(), TodaysDate() ); <-- illegal
>>e.insert( e.end() -1, TodaysDate() ); <-- legal

>>Why does --e.end() will modify temporaries of Date*,
while
>>e.end()-1 can execute?

>>Thanks in advance,

>You're using the VC6 vector, whose iterators are plain
pointers. The
>expression e.end() returns a pointer, which is not
modifiable, as it's
>a temporary object of a non-class type, so the compiler
rejects
>--e.end(). In VC7, it would work, because its

vector::iterator is a

- Show quoted text -

Quote:
>class type, its operator-- is a member function, and you
can call
>member functions on temporaries of class type. In
general, that's a
>good thing, as it's sometimes convenient to say things
like X().y().

>The error message talks about lvalues, but these are both
rvalues. The
>whole concept has become rather blurred in C++. On the
other hand,
>e.end()-1 doesn't modify anything, and the subtraction
operator can
>use constants or temporaries. It only requires rvalues.

>Bonus points to anyone who can explain the following:

>#include <vector>

>void g(std::vector<int>::iterator&);

>void f(std::vector<int>& x)
>{
>   g(x.end()); // Illegal.
>   g(--x.end()); // Fine in VC7!
>}

>--
>Doug Harrison
>Microsoft MVP - Visual C++
>Eluent Software, LLC
>http://www.eluent.com
>Tools for VC++, VS.NET, and Windows
>.



Tue, 28 Dec 2004 03:19:10 GMT  
 end() operation
I guess you can think about them this way. It is just a visualization to
help you understand the concept, anyway, so it is good as long as you
find it convenient.
--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken


So, the function return value is an "anonymance" const
variable, which cannot be referred to?

Hope this time I am right.

Thanks,

Andy

Quote:
>-----Original Message-----
>There is still a difference. You can take address of a
const variable,
>resulting in a pointer to const. You cannot assign though
this pointer,
>but you can, for example, print the address of the
variable and get a
>real memory location. But you cannot take address of an
rvalue - it does
>not have one.
>--
>With best wishes,
>    Igor Tandetnik

>"For every complex problem, there is a solution that is
simple, neat,
>and wrong." H.L. Mencken



>> Hi Igor,

>> Thanks you for your excellent explanation!

>> Can I say that if a function doesn't return a reference,
>> it will return an anonymous temp variable, which is
like a
>> const variable?

>> Regards,

>> Andy

>> >-----Original Message-----
>> >lvalue is, roughly speaking, something that can occur
on
>> the left side
>> >of assignment. rvalue is any expression that is not an
>> lvalue.

>> >To be legal on the left side of an assignment, the
>> expression must refer
>> >to a memory location. Suppose you have (int x)
variable.
>> Then (x) refers
>> >to a memory location occupied by x variable and thus
you
>> can write (x =
>> >10). But (x + 1) does not refer to any memory location,
>> thus you cannot
>> >write (x + 1 = 10).

>> >A return value of a function is not an lvalue unless it
>> returns a
>> >reference:

>> >int global;
>> >int f1() {return global;}
>> >int* f2() {return &global;}
>> >int& f3() {return global;}

>> >// Illegal. f1 returns a copy of global.
>> >// Said copy does not occupy any particular memory
>> location
>> >f1() = 1;

>> >// Legal. f2 returns a pointer to global. This pointer,
>> when
>> >dereferenced,
>> >// refers to a particular memory location occupied by
>> global.
>> >*f2() = 2;

>> >// Also legal. Very similar to case 2, only the syntax
is
>> maybe somewhat
>> >cleaner.
>> >// f3 directly returns a reference to memory occupied
by
>> global.
>> >f3() = 3;

>> >Now, the -- operator is supposed to get the value of
>> expression,
>> >decrement it, and put the value back. --exp is
>> essentially the same as
>> >(exp = exp - 1). Thus, an lvalue is required.
>> >--
>> >With best wishes,
>> >    Igor Tandetnik

>> >"For every complex problem, there is a solution that is
>> simple, neat,
>> >and wrong." H.L. Mencken



>> >> Igor,

>> >> I guess rvalue means const variable. But the
following
>> >> code doesn't work as well. Can you explain?

>> >> Date* f();
>> >> p = --f();

>> >> Thanks,

>> >> Andy
>> >> >-----Original Message-----
>> >> >vector::end returns an rvalue, but -- operator
needs an
>> >> >lvalue. --e.end() does not work for the same reason
for
>> >> which

>> >> >e.end() = e.begin();

>> >> >does not work.
>> >> >--
>> >> >With best wishes,
>> >> >    Igor Tandetnik

>> >> >"For every complex problem, there is a solution
that is
>> >> simple, neat,
>> >> >and wrong." H.L. Mencken



>> >> >> Hi,

>> >> >> Can anyone help me explain why the two lines of
the
>{ w?  
> W  ?VL??    > >> >> following code are not same?

>> >> >> vector<Date> e;
>> >> >> ...
>> >> >> e.insert( --e.end(), TodaysDate() ); <-- illegal
>> >> >> e.insert( e.end() -1, TodaysDate() ); <-- legal

>> >> >> Why does --e.end() will modify temporaries of
Date*,
>> >> while



Tue, 28 Dec 2004 03:18:09 GMT  
 end() operation
Remember, we are talking about whether or not the code compiles. The
iterator may be valid or invalid only at run time. At compile time you
just have an expression of type iterator, without any semantics attached
to it.
--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken


Quote:
> Hi,

> My explanation is the e.end() is not a valid iterator.
> Thus, std::vector<int>::iterator& cannot refers to it.

> Regards,

> Andy



Tue, 28 Dec 2004 03:56:26 GMT  
 end() operation

Quote:

> My explanation is the e.end() is not a valid iterator.
> Thus, std::vector<int>::iterator& cannot refers to it.

As Igor notes, that's a run-time distinction whereas Doug was looking
for a problem that can be detected at compile-time.

No, in this case the reason that's disallowed is a technicality in the
standard.  I don't remember the exact reasons why they decided to do
it, but they disallowed binding temporaries to non-const references.
The upshot is, of course, that they thought the benefits in reducing
unexpected behavior outweighed the costs in taking away a possible
construct, but I don't recall exactly what forms of unexpected behavior
they were trying to prevent.



Tue, 28 Dec 2004 06:36:07 GMT  
 end() operation
Something like this:

class Integer
{
    int n;
public:
    Integer(int x) : n(x) {}
    Integer& operator=(int x) {n = x; return *this};

Quote:
};

void SetToZero(Integer& value) {value = 0;}

int x = 5;
// A temporary Integer is created and bound to a reference
SetToZero(x);
cout << x; // Surprise: x is still 5

--
With best wishes,
    Igor Tandetnik

"For every complex problem, there is a solution that is simple, neat,
and wrong." H.L. Mencken


Quote:
> No, in this case the reason that's disallowed is a technicality in the
> standard.  I don't remember the exact reasons why they decided to do
> it, but they disallowed binding temporaries to non-const references.
> The upshot is, of course, that they thought the benefits in reducing
> unexpected behavior outweighed the costs in taking away a possible
> construct, but I don't recall exactly what forms of unexpected
behavior
> they were trying to prevent.



Tue, 28 Dec 2004 21:34:09 GMT  
 
 [ 23 post ]  Go to page: [1] [2]

 Relevant Pages 

1. Detecting the end of a resizing operation

2. how do i place an end of string char at the end of a string

3. Loosing Memory when Start end ends an Dialog

4. What is end after strtol("0x", &end, 0)?

5. Progress indicator for async WebRequest operations?

6. BITS OPERATION

7. Perform Source Control Operations from .NET Code

8. fatal error LNK1256: ALINK operation failed (80070002): The system cannot find the file specified

9. a question about file operation.

10. Prevent Paste Operation in NumericUpDown Control (C#)

11. address-of (&) operations in managed C++

12. dragdrop textbox operation over form

 

 
Powered by phpBB® Forum Software