Thread: Basic things I need to know

Originally Posted by maxorator

zx-1, the second one works with 16bit, 32bit and 64bit Unicode versions too.

Nope. That'd be with sizeof(wchar_t), assuming there's a difference between wide and and narrow chars.

I see no differences then because sizeof(char) is always 1 byte.

Originally Posted by Queatrix

So much for inactive.

Actually it was midnight. I just thought I'd look if there's something interesting here before I went to sleep.

Originally Posted by maxorator

I see no differences then because sizeof(char) is always 1 byte.

That's 95% correct. There is a difference, albeit a somewhat esoteric one.
It was really kind of a trick question. :-)

Hmm, you can define char to be something else?

No. Answer:
8192 is the same as (int)8192.
8192 * sizeof(char) is the same as (size_t)8192.

I assert that porting legacy code is the only valid reason for having "using" in your code. It decreases readability; putting std:: in front of everything makes it far more clear what's going on.

I think that this is another valid use of "using":

Code:

void ClassName::swap(ClassName& x) {
    using std::swap;
    swap(member1, x.member1);
    swap(member2, x.member2);
}

At the initial point when the code was written, it is possible that the types of member1 and member2 do not yet have their own (presumably optimised) swap functions. As such, the standard swap algorithm would be used. At some later point, this might change, and thus a re-compile should have ClassName::swap pick up the optimisations automatically.

Here is another valid use of "using":

Code:

#include <iostream>

class Base {
public:
    void memberFunction() {
        std::cout << "Base::memberFunction()" << std::endl;
    }

    virtual void memberFunction(int num) {
        std::cout << "Base::memberFunction(" << num << ")" << std::endl;
    }
};

class Derived : public Base {
public:
    using Base::memberFunction;
    virtual void memberFunction(int num) {
        std::cout << "Derived::memberFunction(" << num << ")" << std::endl;
    }
};

int main() {
    Derived x;
    x.memberFunction();
}

If the "using Base::memberFunction;" was commented out, there would be a compile error, since Derived::memberFunction(int) hides the name "memberFunction" in the Base class' scope. As such, a call to Base::memberFunction() from x would be invalid.

I think Cat was referring to the using statement, not the using declaration. But far be it from me to place words in his mouth

zx-1: it actually took me two looks on your code to find the difference. Very nice example.

maxorator: no, but you need to learn good design.

Well, I see the difference too, one of them is shorter than the other one.

4. In C, it is in the <string.h> library.

Look again.

6. Do you mean kind of overload the template with a template function that has parameters types specified, so when those types are used in the function, that function template is used?

I mean that you can have a generic template class, like vector<>, but also a specialized version, such as vector<bool>, which has a slightly different behaviour.

What should you do if you detect an error while in a constructor? What about a destructor? Why is auto_ptr<> not appropriate for holding pointers that will be stored in standard containers? What is a good alternative? What is the airspeed velocity of an unladen swallow? Is that airspeed sufficient to carry a coconut?

Look again.

Oh, sorry, accidentally compiled it as C++, stdio.h of course.

The question: What header file is tolower() in?

Originally Posted by maxorator

[...] stdio.h of course.

Wrong! Better start using your grepping power.

Third time lucky.

Better start using your grepping power.

Or man tolower or google("site:cppreference.com tolower") or countless other ways.

What's the difference? Stdio.h automatically includes ctype.h.
What do you mean by "man"?