d*******n
发帖数: 524 | 1 程序在后面。
我的理解是“Hello World”是内存里一段const char[]，
foo2之所以不行是因为除了foo2这个function之后，这个char 的array就被release了。
但foo1难道不是相同的情况吗？为什么
cout << foo1() <
这一行就可以输出Hello World呢？
请指教
#include
#include
using namespace std;
char* foo1();
const string& foo2();
int main(int argc, _TCHAR* argv[])
{
int i;
cout << foo1() <
cout << foo2() << endl;
cin >> i;
return 0;
}
char* foo1()
{
return "Hello World";
}
const string& foo2()
{
return "Hello World";
} |
|
X****r
发帖数: 3557 | 2 你理解得不对。
string literal，比如你这里的"Hello World"，是一直存在不会被释放的。
foo2之所以不行是因为它返回了一个string临时变量的引用。
你把这个临时变量显式地写出来就知道了：
const string& foo2()
{
string temp("Hello World");
return temp;
}
这里临时变量temp在foo函数结束之后就释放了，但是main里还在继续使用它。
了。 |
|
i**********e
发帖数: 1145 | 3 class Foo {
// bla bla bla
};
class A{
public:
Foo foo1() {
return x;
}
const Foo &foo2() {
return x;
}
private:
Foo x;
};
通常没必要的话直接返回 Foo object 就可以了。
返回 const Foo & 主要是在以下的情况:
Foo x = A().foo2();
避免不必要的两次 copy（例如：A().foo1())。但是现在的编译器都很聪明，A().foo1
() 这种情况也只 copy 一次。
还有一种情况返回 const Foo & 的目的就是避免以下奇怪的情况：
(A().foo2() = x) = y;
如果 foo2() 的返回值定义为 Foo & 就反而会编译通过。
想想看 assignment operator 的返回值你就知道我在说什么意思了。在 primitive
type 里：
int x, y, z;
(x = y) = z;
虽然以上的含义很多人都搞不懂，但是语法是对的。
简单来说，在你自己定义的 user type，如... 阅读全帖 |
|
c****y
发帖数: 24 | 4 来自主题: Programming版 - C++疑问 1. A::foo()是private function, B::foo()也是，需要改成public
2. a 是个A*， A中没有foo2()，不能通过 a 访问 B中 foo2()
关于private里面定义virtual function的两个问题。对于以下程序，
1. a->foo()编译不能通过，说是访问了private member.这是不是表明private里面定
义virtual function毫无意义啊？
2. 既然不被允许访问private member, 这说明complier还是把*a当作B的Object. 然而
a->foo2()也不能通过，因为A没有这个function。为什么作为B的Object连自己public
的member都不能访问呢？
#include
using namespace std;
class A {
int a;
virtual void foo(){
cout << "A:foo" << endl;
}
};
class B:public A{
int b; |
|
b*******n
发帖数: 449 | 5 short cycle碰到傻逼coder就是埋炸弹。用户测不全，以后就是在生产环境中核弹。
比如一个coder手挺快，出活利索，manager挺喜欢。终于由此染指他的code了，原来全
tmd的都是即时贴。
比如
foo1（string s){
<---- 补丁放到这
foo2 (s, true);
}
foo2(sting s, boolean t){ //核心实现部分
...
}
由于某bug，需要对s做处理后，在做实际工作，结果补丁直接打到foo1处，完全不管
foo2是否被别的调用，和以后是否被别的code调用。
这种情况到处都是，基本少就是bug出来顺着看，第一处能fix的就改那里就完了。
cycle真是短，可是天天bug真不少。可manager看起来觉得就是又能出活，又能改bug。
咱这种，提交版本后基本没啥事的，看起来就是出货慢，还不会修bug。
需求看的不够远，天天折腾。 |
|
H****S
发帖数: 1359 | 6 Any reason you have to make Foo.Bar polymorphic? If you make it monomorphic
(get rid of [A]), it actually compiles and is runnable.
// in scala
class Foo {
abstract class Bar(val id: String) {}
}
// in java
public class MainFoo {
public static void main(String... args) {
Foo2 foo = new Foo2();
Foo2.Bar bar = foo.new Bar("id") {};
}
}
比如scala里： |
|
F*****n
发帖数: 1552 | 7 来自主题: Programming版 - C++疑问 关于private里面定义virtual function的两个问题。对于以下程序，
1. a->foo()编译不能通过，说是访问了private member.这是不是表明private里面定
义virtual function毫无意义啊？
2. 既然不被允许访问private member, 这说明complier还是把*a当作B的Object. 然而
a->foo2()也不能通过，因为A没有这个function。为什么作为B的Object连自己public
的member都不能访问呢？
#include
using namespace std;
class A {
int a;
virtual void foo(){
cout << "A:foo" << endl;
}
};
class B:public A{
int b;
void foo(){
cout << "B:foo" << endl;
}
public:
void foo2(){
cout << |
|
A*******e
发帖数: 2419 | 8 什么叫吃掉？
Foo1(X&& x);
Foo2(const &X);
Foo1(X());
Foo2(X());
我是问上面这两个有什么区别。 |
|
s***n
发帖数: 373 | 9 同一个interface内的函数互相调用的话，应该用
[self foo1];
[self foo2];之类的吧？ |
|
s***n
发帖数: 373 | 10 sorry,我的意思是 在实现一个interface的时候
- (void) foo2
{
//需要调用foo1, foo1也是这个interface的一个method
//是不是这样？
[self foo1];
}
thank |
|
m******t
发帖数: 2416 | 11
String
Well I know this is definitely true for the simple cases, e.g., new String("
Hello") or s = "Hello" would always map to the same entry in the constant
pool.
What I'm not sure is cases like:
String s1 = "Hello World";
String s2 = foo1.bar1() + foo2.bar2();
If s2 ends up having exactly "Hello World", would that be the same entry in
the pool? To achieve that, the JVM would have to do a lookup after _every_
concatenation, which is probably more inefficient than allocating a new
buffer.
The |
|
g****y
发帖数: 436 | 12 foo(int[][] lala);
foo2(Double[][] lala);
现在想只保留一个generic的fooG。
google半天，没有结果。。
请问有没有这种generic array？谢谢！ |
|
Y**G
发帖数: 1089 | 13 C++:
BYTE[] buffer = new Buffer[1024];
FOO *foo1 = new &buffer[0] ();
FOO *foo2 = new &buffer[sizeof(FOO)] ();
C++这样用户可以接管对象的内存管理. Java中有何替代? |
|
d*******n
发帖数: 524 | 14 所以临时的东西是那个reference，而char array本身却并不临时？
那么所有的在程序中提到的这种字符串（想这个"Hello World")都是一直存在
于内存中直到程序结束？
那么他们被放在内存中的什么地方呢？肯定不是stack里面，由于不是dynamic
memory allocation，那也不是heap上。 |
|
X****r
发帖数: 3557 | 15 While it really depends on individual compilers,
string literals are usually stored in a const data segment. |
|
w*****3
发帖数: 101 | 16 class Foo{
public:
Foo(int capacity);
....
private:
vector _stack;
....
};//class Foo
Foo(int capacity){ //Foo1
//wrong, _stack still empty outside the constructor scope
vector_stack(capacity);
}
Foo(int capacity){ //Foo2
//right, _stack initialized
_stack = vector(capacity;
}
Questions:
why vector_stack(capacity); in the constructor Foo1 doesn't work
Thanks |
|
d****p
发帖数: 685 | 17 iterator for certain containers (eg vector> is implemented as raw pointer -
you can think as:
template
class Iterator
{
....T* _M_current;
}
After optimization is turned on, the thin wrapper will be thown away by
compiler and you will have the
same raw metal code.
For example, you have two functions:
int foo1(std::vector::const_iterator intItr)
{ return *intItr + 1; }
and
int foo2(const int* intPtr)
{ return *intPtr + 1; }
Both functions generate the around same assembly snipet: |
|
d****p
发帖数: 685 | 18 I recently got confused about one thing.
Previously I have class design as:
class IFoo { ... } // abstract class
class Foo1 : public IFoo { ... }
class Foo2 : public IFoo { ... }
Recently all the code was modified by a colleague as:
class IFoo { ... }
class Foo1 { Impl *pImpl ... }
class Foo1::Impl { ... }
In short, the implementation was moved from Foo to Foo::impl, which
is an internal class.
What's the benefit of doing so? To me this is not nice since Foo is
suppose to be implementat |
|
b*******n
发帖数: 449 | 19 foo2以后再其他代码被调用怎么测。
agile这玩意就是假设别人都跟他一样nb，一样通晓几乎所有的代码，一样的代码质量
，一样的风格。
事实上几乎是不存在的，除了自己一个轮轮子的。 |
|
d****i
发帖数: 4809 | 20 问题是几个函数分别take不同类型的参数，
void foo(SmartShortenedName ssn)；
void foo2(AnotherClass ac);
void foo3(YetAnotherClass yac);
结果你全部给他传入auto类型。。。这不是混淆静态语言和动态语言的本质本征区别吗？
这个时候就看出写全的优势了。 |
|
d****i
发帖数: 4809 | 21 没看懂，头文件里应该没有任何具体实现的细节，只有函数/类/变量的声明，怎么会有
问题呢？比如下面的头文件：
//my_header.h
int foo1();
void foo2(char* a);
class MyClass {
public:
bool foo3(int a);
};
所有的实现都应该放在cpp文件里面进行，哪怕是用了template也是如此。 |
|
d****e
发帖数: 2395 | 22 wow, foo2 is such an angel!! |
|
