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";
} |
|
l*********i
发帖数: 483 | 2 看了那个 C++ lite FAQ，还是没有搞定：
//cppfile.cpp
＃include
void foo1(){
std::cout<<"this is foo1()"<
}
//cppfile.h
extern "C" {
void foo1();
};
//cfile.c
#include "cppfile.h"
main()
{
foo1();
}
编译:
g++ -c cfile.c
g++ -c cppfile.cpp
g++ -o out.bin cfile.o cppfile.o
最后link的时候总是出错"cfile.o: In function `main':
cfile.c:(.text+0x5): undefined reference to `foo1'
collect2: ld returned 1 exit status
"
哪位给指点一下？多谢多谢。 |
|
s*********d
发帖数: 165 | 3 最近发现一个不错的vimrc
http://vim.spf13.com
现在一旦保存java文件:w，vim就会自动编译。不过很多java classes都事packaged的
，比如说
File directory:
~/proj/bin/com/example/package/foo.class
~/proj/bin/com/example/package/foo1.class
~/proj/src/com/example/package/foo.java
~/proj/src/com/example/package/foo1.java
Class foo need to use class foo1. Using terminal, here is how I can compile
cd ~/proj/bin
javac -d ./ ../src/com/example/package/foo.java
(1, $CLASSPATH = "~/proj/bin", 2, this way only works when we cd to ~proj/
bin. )
With s... 阅读全帖 |
|
i**********e
发帖数: 1145 | 4 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，如... 阅读全帖 |
|
s***n
发帖数: 373 | 5 sorry,我的意思是 在实现一个interface的时候
- (void) foo2
{
//需要调用foo1, foo1也是这个interface的一个method
//是不是这样？
[self foo1];
}
thank |
|
d****p
发帖数: 685 | 6 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 |
|
p**********s
发帖数: 115 | 7 我来解typedef那题:
#include
using namespace std;
void staticFun(int num) {
cout << "static function" << endl;
}
class foo{
public:
void classFun(int num) {
cout << "function in a class" << endl;
}
};
typedef void (*myStaticFun) (int);
typedef void (foo::*myClassFun) (int);
int main()
{
myStaticFun testStaticFun = staticFun;
testStaticFun(6);
foo foo1;
myClassFun testClassFun = &foo::classFun;
(foo1.*testClassFun)(6);
return 0;
} |
|
w***t
发帖数: 428 | 8 像这样用了 - 号定义，就用[self ...];
不然就跟c一样，void foo1(){}，那就用 self.foo1(); |
|
r*********r
发帖数: 3195 | 9 gnu has some programs in the "binutils" package. they are very useful.
like nm, c++filt, objdump, ldd etc.
in this example, you can type: "nm cppfile.o", and it tells you that the
function name has be mangled to __Z4foo1v, hence the error message that foo1
cann't be found.
use c++filt to de-mangle the name: "c++filt __Z4foo1v", and it tells you the
original function name is foo1. |
|
w*****3
发帖数: 101 | 10 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 |
|
b*******n
发帖数: 449 | 11 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。
需求看的不够远，天天折腾。 |
|
A*******e
发帖数: 2419 | 12 什么叫吃掉？
Foo1(X&& x);
Foo2(const &X);
Foo1(X());
Foo2(X());
我是问上面这两个有什么区别。 |
|
|
s***n
发帖数: 373 | 14 同一个interface内的函数互相调用的话，应该用
[self foo1];
[self foo2];之类的吧？ |
|
m******t
发帖数: 2416 | 15
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 |
|
Y**G
发帖数: 1089 | 16 C++:
BYTE[] buffer = new Buffer[1024];
FOO *foo1 = new &buffer[0] ();
FOO *foo2 = new &buffer[sizeof(FOO)] ();
C++这样用户可以接管对象的内存管理. Java中有何替代? |
|
r****t
发帖数: 10904 | 17 这个practice不好，这让module1 depends on global foo.
如果一定要用global变量, 写到一个module里面：
globalvars.py:
foo = "bar"
foo1 = "bar1"
然后在主程序里头：
import globalvars
or
from globalvars import * |
|
X****r
发帖数: 3557 | 18 你理解得不对。
string literal，比如你这里的"Hello World"，是一直存在不会被释放的。
foo2之所以不行是因为它返回了一个string临时变量的引用。
你把这个临时变量显式地写出来就知道了：
const string& foo2()
{
string temp("Hello World");
return temp;
}
这里临时变量temp在foo函数结束之后就释放了，但是main里还在继续使用它。
了。 |
|
d*******n
发帖数: 524 | 19 所以临时的东西是那个reference，而char array本身却并不临时？
那么所有的在程序中提到的这种字符串（想这个"Hello World")都是一直存在
于内存中直到程序结束？
那么他们被放在内存中的什么地方呢？肯定不是stack里面，由于不是dynamic
memory allocation，那也不是heap上。 |
|
X****r
发帖数: 3557 | 20 While it really depends on individual compilers,
string literals are usually stored in a const data segment. |
|
h****8
发帖数: 599 | 21 因为foo1里面你又新定义并且初始化了一个变量_stack,不是原来那个成员变量
把vector去掉，改为 _stack(capacity);就行了 |
|
d****p
发帖数: 685 | 22 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****i
发帖数: 4809 | 23 没看懂，头文件里应该没有任何具体实现的细节，只有函数/类/变量的声明，怎么会有
问题呢？比如下面的头文件：
//my_header.h
int foo1();
void foo2(char* a);
class MyClass {
public:
bool foo3(int a);
};
所有的实现都应该放在cpp文件里面进行，哪怕是用了template也是如此。 |
|
