I wouldn't enjoy trying to write assembly in 3D... but i can't wait until the first time the safety protocols disengage for no apparent reason and cause my C++ to attack me.Brynet-Inc wrote:Someone build a freaking Holodeck already
Wouldn't that be oh so fun?
I'm pretty afraid of my C...Tyler wrote:but i can't wait until the first time the safety protocols disengage for no apparent reason and cause my C++ to attack me.
isn't that taking C++ too far...I personally can't see much any use for many of the operator overloads, and [] I can only see a use for in lists and tablesIf you use pointers with C++ overloaded class operators it can get tricky in some moments.
operator-> and operator* are very useful for implementing smart pointers. operator() is very useful for implementing functors. +, -, ++ and -- are useful for implementing iterators.hckr83 wrote:isn't that taking C++ too far...I personally can't see much any use for many of the operator overloads, and [] I can only see a use for in lists and tablesIf you use pointers with C++ overloaded class operators it can get tricky in some moments.
Well. I suppose for instance: vector math where you want to make the code a little more readable using some of the syntactic sugar C++ provides.I personally can't see much any use for many of the operator overloads.
Code: Select all
class cVec3
{
public:
float x, y, z;
cVec3();
cVec3(float _x, float _y, float _z);
~cVec3();
cVec3 operator-(const cVec3 &a);
void debug();
};
cVec3::cVec3()
{
}
cVec3::cVec3(float _x, float _y, float _z)
{
x = _x; y = _y; z = _z;
}
cVec3::~cVec3()
{
}
void cVec3::debug()
{
printf("%x: %f,%f,%f\n", this, x, y, z);
}
cVec3 cVec3::operator-(const cVec3 &a)
{
cVec3 r;
r.x = x - a.x;
r.y = y - a.y;
r.z = z - a.z;
return r;
}
int main(int argc, char *argv[])
{
cVec3 a(10.0, 10.0, 10.0), b(2.0, 2.0, 2.0), c;
/// The entire function call is broken down with optimization turned on (for GCC)
c = a - b;
c.debug();
return 1;
}
hmm...smart pointers just seem like too much overhead for such a commonly done thing(I tend to use too many pointers though)Colonel Kernel wrote:operator-> and operator* are very useful for implementing smart pointers. operator() is very useful for implementing functors. +, -, ++ and -- are useful for implementing iterators.hckr83 wrote:isn't that taking C++ too far...I personally can't see much any use for many of the operator overloads, and [] I can only see a use for in lists and tablesIf you use pointers with C++ overloaded class operators it can get tricky in some moments.
But operator overloading and pointers-to-objects don't mix well syntactically, as you've seen. Use references or just use the objects directly.
I'm pretty sure there's no overhead.hckr83 wrote:btw, Are templates well optimized? If they aren't, with each call to a template, you'd reproduce code...and with many calls, it could eventually be MBs of duplicate wasted code! (if your not careful)
Code: Select all
template <class TYPE> TYPE MyTest(TYPE& a)
{
return a;
}
int main(int argc, char *argv[])
{
float a;
unsigned int b;
a = MyTest<float>(a);
b = MyTest<unsigned int>(b);
return 1;
}
Here are the two functions it produced just so you can notice it only created one instance of each.lea 0x4(%esp),%ecx
and $0xfffffff0,%esp
pushl 0xfffffffc(%ecx)
push %ebp
mov %esp,%ebp
push %ecx
sub $0x14,%esp
lea 0xfffffff8(%ebp),%eax
mov %eax,(%esp)
call 8048420 <_Z6MyTestIfET_RS0_>
fstps 0xfffffff8(%ebp)
lea 0xfffffff4(%ebp),%eax
mov %eax,(%esp)
call 8048434 <_Z6MyTestIjET_RS0_>
mov %eax,0xfffffff4(%ebp)
mov $0x1,%eax
add $0x14,%esp
pop %ecx
pop %ebp
lea 0xfffffffc(%ecx),%esp
ret
So no it does not continually add overhead each time you make a function call, instead it just creates one instance of this function in machine output.08048420 <_Z6MyTestIfET_RS0_>:
8048420: 55 push %ebp
8048421: 89 e5 mov %esp,%ebp
8048423: 83 ec 04 sub $0x4,%esp
8048426: 8b 45 08 mov 0x8(%ebp),%eax
8048429: 8b 00 mov (%eax),%eax
804842b: 89 45 fc mov %eax,0xfffffffc(%ebp)
804842e: d9 45 fc flds 0xfffffffc(%ebp)
8048431: c9 leave
8048432: c3 ret
8048433: 90 nop
08048434 <_Z6MyTestIjET_RS0_>:
8048434: 55 push %ebp
8048435: 89 e5 mov %esp,%ebp
8048437: 8b 45 08 mov 0x8(%ebp),%eax
804843a: 8b 00 mov (%eax),%eax
804843c: 5d pop %ebp
804843d: c3 ret
804843e: 90 nop
804843f: 90 nop
What is such a commonly-done thing? Calling new and delete? Managing reference counts...? The overhead added by a smart pointer is negligible, because any worthwhile compiler will inline most of the smart pointer's methods. On the other hand, the benefits of using smart pointers are tremendous as they make it much more difficult to inject subtle memory leaks into your code during development.hckr83 wrote:hmm...smart pointers just seem like too much overhead for such a commonly done thing(I tend to use too many pointers though)
You should spend some time learning how to use the algorithms in the STL. In a nutshell, function objects make it easy to apply a custom operation over a collection in a generic way. For example, let's say you have a vector<Foo*>, and each Foo has a method getBar() that returns a pointer to the Bar belonging to that Foo. If you want to "strip" the Foos off and end up with a vector<Bar*>, you can do that easily by writing a short function object that just calls getBar() on a Foo, and then call std::transform() on your input and output vectors. It's quite nifty, at least for C++.function objects?! I didn't even know you could do that! I don't see any practical application right now, but I'm sure there is some good use for it..
Yeah, iterators are complicated to implement properly. I wouldn't even bother. The point is that without overloading operator ++ and -- it would be impossible for the STL to provide generic algorithms that work on all kinds of containers, including plain-jane C arrays. But as far as implementing iterators goes, better the STL guys than me.++ and -- I can actually see a use for in my list thingy...like being able to override the = operator and such....meh...kidna complicated though..lol
In terms of speed, templates are very well optimized. Everything basically gets inlined. In terms of space, if you instantiate a template with many different types, then yes, it can consume a lot of space. As others have said, it's not per "call" though, it's per unique instantiation. For example, if you have a vector<Foo> and a vector<Bar>, the code for vector will be replicated once for each.btw, Are templates well optimized? If they aren't, with each call to a template, you'd reproduce code...and with many calls, it could eventually be MBs of duplicate wasted code! (if your not careful)