m*********a
发帖数: 3299 | 1 Foo 是一个object
Foo &myFoo=*(new Foo());
和
Foo myFoo=*(new Foo());
myFoo都是Foo的一个reference吧？ |
x********q
发帖数: 108 | 2 第二个是个copy。memory leak
【在 m*********a 的大作中提到】
: Foo 是一个object
: Foo &myFoo=*(new Foo());
: 和
: Foo myFoo=*(new Foo());
: myFoo都是Foo的一个reference吧？
|
f*******t
发帖数: 7549 | 3 应该有rvalue优化吧？
【在 x********q 的大作中提到】
: 第二个是个copy。memory leak
|
m*********a
发帖数: 3299 | 4 多谢。终于懂了。
真是太坑了，java 的实现多简单啊
Foo myFoo=new Foo();
和
c++的
Foo &myFoo=*(new Foo());
【在 x********q 的大作中提到】
: 第二个是个copy。memory leak
|
p***o
发帖数: 1252 | 5 你这都是哪儿看来的诡异用法? 还是自己琢磨出来的?
【在 m*********a 的大作中提到】
: 多谢。终于懂了。
: 真是太坑了，java 的实现多简单啊
: Foo myFoo=new Foo();
: 和
: c++的
: Foo &myFoo=*(new Foo());
|
m*********a
发帖数: 3299 | 6 看书看得，比较c和java 语言
主要是学java的
【在 p***o 的大作中提到】
: 你这都是哪儿看来的诡异用法? 还是自己琢磨出来的?
|
p***o
发帖数: 1252 | 7 扔了吧, 找本靠谱的看。
【在 m*********a 的大作中提到】
: 看书看得，比较c和java 语言
: 主要是学java的
|
m*********a
发帖数: 3299 | 8 推荐一本把，最好能下载，买也可以。
【在 p***o 的大作中提到】
: 扔了吧, 找本靠谱的看。
|
p***o
发帖数: 1252 | 9 C++的书还是Java的书？
【在 m*********a 的大作中提到】
: 推荐一本把，最好能下载，买也可以。
|
x********q
发帖数: 108 | 10 Return value optimization? 应该不是这个case
【在 f*******t 的大作中提到】
: 应该有rvalue优化吧？
|
|
|
g*********e
发帖数: 14401 | 11 第二个创造了两个foo new出来的那个无法被delete
【在 m*********a 的大作中提到】
: Foo 是一个object
: Foo &myFoo=*(new Foo());
: 和
: Foo myFoo=*(new Foo());
: myFoo都是Foo的一个reference吧？
|
g*********e
发帖数: 14401 | |
G***l
发帖数: 355 | 13 那要Foo实现了move constructor。即便如此，那也是move了new Foo里面的东西，那个
new Foo本身还是leak了。
从java过来的用c++，最应该注意的是c++有value semantics。
除了基本类型，java里只有Foo f = new Foo();
c++有Foo* f = new Foo();和Foo f;而且后者更常用。
【在 f*******t 的大作中提到】
: 应该有rvalue优化吧？
|
N******K
发帖数: 10202 | 14 C++ 和 Java 势不两立啊 哈哈
【在 G***l 的大作中提到】
: 那要Foo实现了move constructor。即便如此，那也是move了new Foo里面的东西，那个
: new Foo本身还是leak了。
: 从java过来的用c++，最应该注意的是c++有value semantics。
: 除了基本类型，java里只有Foo f = new Foo();
: c++有Foo* f = new Foo();和Foo f;而且后者更常用。
|
g*********e
发帖数: 14401 | |
t*****n
发帖数: 4908 | 16 这种C++的学习方式，根本就是走火入魔。把C++当带类的C就行了。代码写成这样，以
后维护非常麻烦。要是是面试题，出题的人没有什么职业道德。 |
m*********a
发帖数: 3299 | 17 java的，基础的就不用了，最好是efficiency java啥的
【在 p***o 的大作中提到】
: C++的书还是Java的书？
|
m*********a
发帖数: 3299 | 18 这个就是很不规则的
Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
但是Foo myFoo;的话C++，如果出了code block{}的话，
myFoo会call Foo()和 ~Foo();
不知是为啥，大牛解释一下。
Java是咋靠destructor的？
【在 G***l 的大作中提到】
: 那要Foo实现了move constructor。即便如此，那也是move了new Foo里面的东西，那个
: new Foo本身还是leak了。
: 从java过来的用c++，最应该注意的是c++有value semantics。
: 除了基本类型，java里只有Foo f = new Foo();
: c++有Foo* f = new Foo();和Foo f;而且后者更常用。
|
w**z
发帖数: 8232 | 19 GC.
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
p***o
发帖数: 1252 | 20
这种最基本的东西随便一本靠谱的C++书都解释得很清楚。
Java没dtor，靠GC管理内存。没dtor管理其他资源实在不方便，
最后Java 7加了个AutoCloseable和try一起当dtor用。
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
|
|
G***l
发帖数: 355 | 21 很规则，不过你要明白这个规则，也就两句话。
1.在stack上的object在out of scope的时候自动清除。
2.在heap上的object在out of scope时候不会清理，需要手动delete。
Java的规则是
1.在stack上的object在out of scope的时候自动清除。
2.在heap上的object在out of scope时候不会清理，GC会在下次collect的时候清理。
不过Java只有基本类型才能放在stack上，其他只能通过new放在heap上。c++所有的类
型，既可以通过new放在heap上，也可以直接放在stack上。
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
m*********a
发帖数: 3299 | 22 哪在c++中可能有这样的memory leak
在main 中，在stack上initiate一个struct node{int value,node *next}
node dummy;
然后在main中call, addNode(node &dummy)
在add中在 heap 上 加一个node
dummy->next=new node();
这样返回的dummy node一个在stack 上，一个heap上。
推出main时，heap上的node还在？
【在 G***l 的大作中提到】
: 很规则，不过你要明白这个规则，也就两句话。
: 1.在stack上的object在out of scope的时候自动清除。
: 2.在heap上的object在out of scope时候不会清理，需要手动delete。
: Java的规则是
: 1.在stack上的object在out of scope的时候自动清除。
: 2.在heap上的object在out of scope时候不会清理，GC会在下次collect的时候清理。
: 不过Java只有基本类型才能放在stack上，其他只能通过new放在heap上。c++所有的类
: 型，既可以通过new放在heap上，也可以直接放在stack上。
|
G***l
发帖数: 355 | 23 退出main当然会不在了。推出main程序就结束了，所有内存都被操作系统回收了。
如果不是main的话那就是个leak。每个new都要有对应的delete。
这些都是最基本的概念，真要用c++你还是读点书吧。如果你只用过java，不会汇编，c
之类的话，不可能在这边看几个帖子或者stackoverflow上看看就能写c++的。
【在 m*********a 的大作中提到】
: 哪在c++中可能有这样的memory leak
: 在main 中，在stack上initiate一个struct node{int value,node *next}
: node dummy;
: 然后在main中call, addNode(node &dummy)
: 在add中在 heap 上 加一个node
: dummy->next=new node();
: 这样返回的dummy node一个在stack 上，一个heap上。
: 推出main时，heap上的node还在？
|
m*********a
发帖数: 3299 | 24 Foo 是一个object
Foo &myFoo=*(new Foo());
和
Foo myFoo=*(new Foo());
myFoo都是Foo的一个reference吧？ |
x********q
发帖数: 108 | 25 第二个是个copy。memory leak
【在 m*********a 的大作中提到】
: Foo 是一个object
: Foo &myFoo=*(new Foo());
: 和
: Foo myFoo=*(new Foo());
: myFoo都是Foo的一个reference吧？
|
f*******t
发帖数: 7549 | 26 应该有rvalue优化吧？
【在 x********q 的大作中提到】
: 第二个是个copy。memory leak
|
m*********a
发帖数: 3299 | 27 多谢。终于懂了。
真是太坑了，java 的实现多简单啊
Foo myFoo=new Foo();
和
c++的
Foo &myFoo=*(new Foo());
【在 x********q 的大作中提到】
: 第二个是个copy。memory leak
|
p***o
发帖数: 1252 | 28 你这都是哪儿看来的诡异用法? 还是自己琢磨出来的?
【在 m*********a 的大作中提到】
: 多谢。终于懂了。
: 真是太坑了，java 的实现多简单啊
: Foo myFoo=new Foo();
: 和
: c++的
: Foo &myFoo=*(new Foo());
|
m*********a
发帖数: 3299 | 29 看书看得，比较c和java 语言
主要是学java的
【在 p***o 的大作中提到】
: 你这都是哪儿看来的诡异用法? 还是自己琢磨出来的?
|
p***o
发帖数: 1252 | 30 扔了吧, 找本靠谱的看。
【在 m*********a 的大作中提到】
: 看书看得，比较c和java 语言
: 主要是学java的
|
|
|
m*********a
发帖数: 3299 | 31 推荐一本把，最好能下载，买也可以。
【在 p***o 的大作中提到】
: 扔了吧, 找本靠谱的看。
|
p***o
发帖数: 1252 | 32 C++的书还是Java的书？
【在 m*********a 的大作中提到】
: 推荐一本把，最好能下载，买也可以。
|
x********q
发帖数: 108 | 33 Return value optimization? 应该不是这个case
【在 f*******t 的大作中提到】
: 应该有rvalue优化吧？
|
g*********e
发帖数: 14401 | 34 第二个创造了两个foo new出来的那个无法被delete
【在 m*********a 的大作中提到】
: Foo 是一个object
: Foo &myFoo=*(new Foo());
: 和
: Foo myFoo=*(new Foo());
: myFoo都是Foo的一个reference吧？
|
g*********e
发帖数: 14401 | |
G***l
发帖数: 355 | 36 那要Foo实现了move constructor。即便如此，那也是move了new Foo里面的东西，那个
new Foo本身还是leak了。
从java过来的用c++，最应该注意的是c++有value semantics。
除了基本类型，java里只有Foo f = new Foo();
c++有Foo* f = new Foo();和Foo f;而且后者更常用。
【在 f*******t 的大作中提到】
: 应该有rvalue优化吧？
|
N******K
发帖数: 10202 | 37 C++ 和 Java 势不两立啊 哈哈
【在 G***l 的大作中提到】
: 那要Foo实现了move constructor。即便如此，那也是move了new Foo里面的东西，那个
: new Foo本身还是leak了。
: 从java过来的用c++，最应该注意的是c++有value semantics。
: 除了基本类型，java里只有Foo f = new Foo();
: c++有Foo* f = new Foo();和Foo f;而且后者更常用。
|
g*********e
发帖数: 14401 | |
t*****n
发帖数: 4908 | 39 这种C++的学习方式，根本就是走火入魔。把C++当带类的C就行了。代码写成这样，以
后维护非常麻烦。要是是面试题，出题的人没有什么职业道德。 |
m*********a
发帖数: 3299 | 40 java的，基础的就不用了，最好是efficiency java啥的
【在 p***o 的大作中提到】
: C++的书还是Java的书？
|
|
|
m*********a
发帖数: 3299 | 41 这个就是很不规则的
Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
但是Foo myFoo;的话C++，如果出了code block{}的话，
myFoo会call Foo()和 ~Foo();
不知是为啥，大牛解释一下。
Java是咋靠destructor的？
【在 G***l 的大作中提到】
: 那要Foo实现了move constructor。即便如此，那也是move了new Foo里面的东西，那个
: new Foo本身还是leak了。
: 从java过来的用c++，最应该注意的是c++有value semantics。
: 除了基本类型，java里只有Foo f = new Foo();
: c++有Foo* f = new Foo();和Foo f;而且后者更常用。
|
w**z
发帖数: 8232 | 42 GC.
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
p***o
发帖数: 1252 | 43
这种最基本的东西随便一本靠谱的C++书都解释得很清楚。
Java没dtor，靠GC管理内存。没dtor管理其他资源实在不方便，
最后Java 7加了个AutoCloseable和try一起当dtor用。
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
G***l
发帖数: 355 | 44 很规则，不过你要明白这个规则，也就两句话。
1.在stack上的object在out of scope的时候自动清除。
2.在heap上的object在out of scope时候不会清理，需要手动delete。
Java的规则是
1.在stack上的object在out of scope的时候自动清除。
2.在heap上的object在out of scope时候不会清理，GC会在下次collect的时候清理。
不过Java只有基本类型才能放在stack上，其他只能通过new放在heap上。c++所有的类
型，既可以通过new放在heap上，也可以直接放在stack上。
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
m*********a
发帖数: 3299 | 45 哪在c++中可能有这样的memory leak
在main 中，在stack上initiate一个struct node{int value,node *next}
node dummy;
然后在main中call, addNode(node &dummy)
在add中在 heap 上 加一个node
dummy->next=new node();
这样返回的dummy node一个在stack 上，一个heap上。
推出main时，heap上的node还在？
【在 G***l 的大作中提到】
: 很规则，不过你要明白这个规则，也就两句话。
: 1.在stack上的object在out of scope的时候自动清除。
: 2.在heap上的object在out of scope时候不会清理，需要手动delete。
: Java的规则是
: 1.在stack上的object在out of scope的时候自动清除。
: 2.在heap上的object在out of scope时候不会清理，GC会在下次collect的时候清理。
: 不过Java只有基本类型才能放在stack上，其他只能通过new放在heap上。c++所有的类
: 型，既可以通过new放在heap上，也可以直接放在stack上。
|
G***l
发帖数: 355 | 46 退出main当然会不在了。推出main程序就结束了，所有内存都被操作系统回收了。
如果不是main的话那就是个leak。每个new都要有对应的delete。
这些都是最基本的概念，真要用c++你还是读点书吧。如果你只用过java，不会汇编，c
之类的话，不可能在这边看几个帖子或者stackoverflow上看看就能写c++的。
【在 m*********a 的大作中提到】
: 哪在c++中可能有这样的memory leak
: 在main 中，在stack上initiate一个struct node{int value,node *next}
: node dummy;
: 然后在main中call, addNode(node &dummy)
: 在add中在 heap 上 加一个node
: dummy->next=new node();
: 这样返回的dummy node一个在stack 上，一个heap上。
: 推出main时，heap上的node还在？
|
g*********e
发帖数: 14401 | 47
this is called RAAI
【在 m*********a 的大作中提到】
: 这个就是很不规则的
: Foo *myFoo=new Foo();的话C++，如果出了code block{}的话，
: myFoo会call Foo()但是不会call ~Foo();需要自己call ~Foo()不？
: 但是Foo myFoo;的话C++，如果出了code block{}的话，
: myFoo会call Foo()和 ~Foo();
: 不知是为啥，大牛解释一下。
: Java是咋靠destructor的？
|
h**********c
发帖数: 4120 | 48 The second one depends on if the copy constructor is wel defined and
overlaoding = operator.
I guess it is legal.
Just a kind of chaining.
【在 m*********a 的大作中提到】
: Foo 是一个object
: Foo &myFoo=*(new Foo());
: 和
: Foo myFoo=*(new Foo());
: myFoo都是Foo的一个reference吧？
|
d****i
发帖数: 4809 | 49 你这个是哪里看来的乱七八糟的东西？C++里面创建对象一般最常用的就两种：
Foo myFoo;
或者
Foo *myFoo = new Foo();
// some code...
delete myFoo;
前者stack后者heap。前者不用你来管理，后者需要你手动delete释放内存。相当与C里
面的malloc和free的配对。
【在 m*********a 的大作中提到】
: Foo 是一个object
: Foo &myFoo=*(new Foo());
: 和
: Foo myFoo=*(new Foo());
: myFoo都是Foo的一个reference吧？
|
h**6
发帖数: 4160 | 50 工作中这样写代码，会被人把手指砍下来贴在布告栏中展览的。 |
|
|
v******y
发帖数: 84 | 51 要用
Foo myFoo=*(new Foo());
正确的话，copy construct要重新定义
Foo(const Foo & rhs){
//memberwise copy of Foo's member from rhs to this
delete &rhs;//prevent memory leak
}
那以后就不能用, Foo myFoo=Foo();
这个delete stack上的Foo()是undefined.
虽然很多程序运行没有问题，但是还是不安全
有啥办法不？
还有如果
Foo *a=new Foo();
Foo b(*a);
a就给释放了。程序完全乱了
c++无法知道object是分配到heap还是stack的。
【在 h**********c 的大作中提到】
: The second one depends on if the copy constructor is wel defined and
: overlaoding = operator.
: I guess it is legal.
: Just a kind of chaining.
|
n*****t
发帖数: 22014 | 52 不要写这种 code，在 construct 里 delete 另一个，老老实实 copy and delete 就
不会有问题了
【在 v******y 的大作中提到】
: 要用
: Foo myFoo=*(new Foo());
: 正确的话，copy construct要重新定义
: Foo(const Foo & rhs){
: //memberwise copy of Foo's member from rhs to this
: delete &rhs;//prevent memory leak
: }
: 那以后就不能用, Foo myFoo=Foo();
: 这个delete stack上的Foo()是undefined.
: 虽然很多程序运行没有问题，但是还是不安全
|
t*****n
发帖数: 4908 | 53 如果你写了Foo b(*a)，你饭碗估计也就砸了。
【在 v******y 的大作中提到】
: 要用
: Foo myFoo=*(new Foo());
: 正确的话，copy construct要重新定义
: Foo(const Foo & rhs){
: //memberwise copy of Foo's member from rhs to this
: delete &rhs;//prevent memory leak
: }
: 那以后就不能用, Foo myFoo=Foo();
: 这个delete stack上的Foo()是undefined.
: 虽然很多程序运行没有问题，但是还是不安全
|
t*****n
发帖数: 4908 | 54 老姜你还跟刷题党较真，难得难得。
【在 n*****t 的大作中提到】
: 不要写这种 code，在 construct 里 delete 另一个，老老实实 copy and delete 就
: 不会有问题了
|
