• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            qiezi的學習園地

            AS/C/C++/D/Java/JS/Python/Ruby

              C++博客 :: 首頁 :: 新隨筆 ::  ::  :: 管理 ::
            標題:Proposal: Operator overloading without temporaries
            作者:Don Clugston <dac@nospam.com.au>

            正文:
            Background: Operator overloading, in the form it exists in C++ and
            currently in D, inherently results in sub-optimal code, because it
            always results in unnecessary temporary objects being created.

            For example,
            X = A - ((B*C) + D)* E;

            becomes:
            T1 = B * C;
            T2 = T1 + D;
            T3 = T2 * E;
            T4 = A - T3;
            X = T4;
            Four objects were created, whereas only one was strictly required.
            In C++, there are libraries like Blitz++ which use complicated
            expression templates in order to avoid these creating these temporaries,
            and provide performance comparable with FORTRAN. I think D can do much
            better...
            Note that temporaries are avoided when using the opXXXAssign() operators
            like +=.

            ===========
            ?? Proposal
            ===========
            (1) Allow the compiler to assume that b = b + c? can be replaced with b
            += c. (In C++, operator + and operator += are just symbols, the compiler
            doesn't know that there is any relationship between them).
            In the example above, this would allow the compiler to generate:
            T1 = B * C;
            T1 += D;
            T1 *= E;

            and we have eliminated two of the three temporaries.
            (2). Fill in the gaps in the operator overloading table by introducing
            opAddAssign_r, opSubAssign_r, etc.

            Just as A.opSubAssign(B)
            is the operation? A -= B? or equivalently? A = A - B, similarly

            A.opSubAssign_r(B)
            would mean
            A = B - A.
            and would only occur when temporaries are generated in expressions. Like
            -=, it's an operation which can frequently be performed very
            efficiently, but at present the language has no way of expressing it.

            Our original example then becomes:

            T1 = B.opMul(C);
            T1.opAddAssign(D);
            T1.opMulAssign(E);
            T1.opSubAssign_r(A);
            X = T1;
            ... and all the useless temporaries are gone!

            More formally, when the expression tree for an expression is generated:
            With a binary operator XXX, operating on left & right nodes:

            if (the left node is *not* an original leaf node) {
            ??? // the left node is a temporary, does not need to be preserved.
            ??? // we don't care if the right node is a temporary or not
            ??? look for opXXXAssign().
            } else if (the the right node is not an original leaf node) {
            ??? // the right node is a temporary
            ??? look for opXXXAssign_r()
            } else {
            ?? // both left and right nodes are leaf nodes, we have to
            ?? // create a temporary
            ??? look for opXXX(), just as it does now.
            }

            These rules also cope with the situation where temporaries are required:
            eg
            X = (A*B) + (C*D);
            becomes
            T1 = A*B;
            T2 = C*D;
            T1 += T2;
            X = T1;

            If this were implemented, it would permanently eradicate (for D) the
            most significant advantage which Fortran has managed to retain over
            object-oriented languages. And I really don't think it would be
            difficult to implement, or have negative side-effects.

            There are a couple of decisions to be made:
            (I) should the compiler use opAdd() and generate a temporary, if
            opAddAssign_r() doesn't exist, to preserve existing behaviour? I think
            the answer to this is YES.
            (II) should the compiler use opAdd() and generate a temporary, if
            oppAddAssign() doesn't exist, to preserve existing behaviour? Again, I'm
            inclined to answer YES.
            (III) If the code includes +=, and there is an opAdd() but no
            opAddAssign(), should the compiler accept this, and just generate an
            opAdd() followed by an assignment?? This would mean that opAdd() would
            generate the += operation as well as +, while opAddAssign() would be a
            performance enhancement. (It would still be possible to have
            opAddAssign() without opAdd(), to have += but not +, but it would not be
            possible to have + without +=). This would mean that += would be
            *purely* syntactic sugar.

            Decision III would be a little more difficult to implement and is of
            less obvious merit, I only mention it as a possibility.

            Comments?
            posted on 2006-03-28 10:31 qiezi 閱讀(532) 評論(0)  編輯 收藏 引用 所屬分類: D
            久久国产精品-国产精品| 国产精品日韩欧美久久综合| 亚洲国产成人久久综合碰| 热RE99久久精品国产66热| 99久久做夜夜爱天天做精品| 久久综合噜噜激激的五月天| 国产亚洲婷婷香蕉久久精品| 久久毛片一区二区| 69久久夜色精品国产69| 免费一级做a爰片久久毛片潮| 久久久亚洲AV波多野结衣| 久久国产精品99精品国产987| 久久综合久久伊人| 国产一区二区三区久久精品| 少妇被又大又粗又爽毛片久久黑人| 亚洲国产精品无码久久一区二区| 亚洲狠狠久久综合一区77777 | 久久久久亚洲AV成人网| 久久人人爽人人爽人人片AV高清| 亚洲国产天堂久久综合网站| 色偷偷偷久久伊人大杳蕉| 亚洲乱亚洲乱淫久久| 无码人妻久久一区二区三区| 久久人妻少妇嫩草AV无码蜜桃| 国产亚洲精久久久久久无码| 亚洲国产成人久久笫一页| 精品久久久久久国产三级| 国产美女久久精品香蕉69| 久久狠狠爱亚洲综合影院| 久久久久无码国产精品不卡| 亚洲狠狠综合久久| 青草影院天堂男人久久| 精品免费久久久久久久| 久久精品国产2020| 久久精品极品盛宴观看| 日韩va亚洲va欧美va久久| 久久久久女教师免费一区| 久久久久久一区国产精品| 久久久久亚洲精品无码网址| 久久伊人色| 久久精品国产精品亚洲精品 |