Re: optimize const T& parameter to T
On Feb 22, 12:24 pm, stephen.clam...@sun.com wrote:
On Thu, 22 Feb 2007 08:57:31 CST, "W Karas" <wka...@yahoo.com> wrote:
On Feb 22, 1:42 am, clamsd-n...@yahoo.com wrote:
On Tue, 20 Feb 2007 12:05:50 CST, "W Karas" <wka...@yahoo.com> wrote:
On Feb 16, 7:48 pm, stephen.clam...@sun.com wrote:
On Fri, 16 Feb 2007 17:23:08 CST, "W Karas" <wka...@yahoo.com> wrote:
Consider a source file that has (only) this:
template <typename T>
void foo(const T &i);
void bar(int i) { foo(i); }
If it was compiled with optimization, is it unreasonable to expect it
should generate the same object code (aside from differences in
mangled names) as this file?
The compiler is in general not allowed to make that "optimization".
Why do you put optimization in quotes? What I suggest would
make the resulting program smaller and faster.
But as I showed later, the optimization is not in general valid.
Sorry, I don't see that. The optimization is valid I think for T a
primitive type or a class with no direct or indirect mutable
data members.
int k = 1;
void foo();
int f(const int& i)
{
foo();
cout << i;
}
/*
int g(int i)
{
foo();
cout << i;}
*/
Your claim is that the compiler can transform the definition of f into
the function g, and change call sites accordingly.
Suppose we call f(k) and foo() modifies k. The modified and unmodified
versions of f have different observable behavior, so the
transformation is not valid. In this example, the compiler does not
know whether foo modifies k, or whether f will be called with k as an
argument.
I still don't agree that this means my suggestion cannot be called
an optimization. It just shows that it's in a category of aggressive
optimizations that can be broken by aliasing, and should not be
enabled by default.
The scenario you describe indicates that "const" doesn't really mean
constant, it actually means read-only. If a hyothetical compiler
had a "--const-really-const" switch that allowed the compiler to
assume const variables are not changed by side effects, then
f() would have to be re-written as follows to work when this
switch was used:
void foo();
template <typename T>
class read_only
{
T &r;
public:
read_only(T &rr) : r(rr) { }
operator T () { return(r); }
}
int f(read_only<int> i)
{
foo();
cout << i;
}
(Except I can't remember now if conversion operators are considered
by function lookup, so it might have to be cout << i.val(); or
something.)
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]