C++中你不知道的语法

左手的ㄟ右手 2022-07-13 09:14 159阅读 0赞

传构造函数，不会引起拷贝构造函数的调用

当传一个一个已经构造好的对象时，

\#include <iostream> \#include <stdio.h> \#include <vector> \#include <algorithm> using namespace std; class Foo \{ public: Foo()\{cout << "ctr" << endl;\} ~Foo()\{cout << "de-ctr" << endl;\} Foo(const Foo& rhs) \{ cout << "copy-ctr" << endl; \} Foo& operator=(const Foo& rhs) \{ cout << "operator=" << endl; \} \}; void f(Foo f) \{ \} int main() \{ Foo a; f(a); return 0; \}

结果为：

ctr copy-ctr dectr dectr

当传参时构造对象时，

int main() \{ f(Foo()); return 0; \}

结果就变成：

ctr dectr

引申：

同理在模板类当中，同样成立，你不要把它看成一个函数调用了，它是也一个临时对象。如下：

\#include <iostream> \#include <stdio.h> \#include <vector> \#include <algorithm> using namespace std; template <typename T> class print \{ public: print()\{cout << "ctr" << endl;\} ~print()\{cout << "de-ctr" << endl;\} print(const print<T>& rhs) \{ cout << "copy-ctr" << endl; \} print<T>& operator=(const print<T>& rhs) \{ cout << "operator=" << endl; \} void operator()(const T& elem) \{ cout << elem << endl; \} \}; void f(print<int> f) \{ f(1); \} int main() \{ f(print<int>()); return 0; \}

new操作符-空间还可以这样分配

\#include <iostream> using namespace std; class Foo \{ public: int i; Foo()\{ cout << "ctr" << endl;\} ~Foo()\{cout << "dectr" << endl;\} Foo(const Foo& rhs) \{ i = rhs.i; cout << "copy-ctr" << endl; \} Foo& operator=(const Foo& rhs) \{ i = rhs.i; cout << "operator=" << endl; return \*this; \} \}; int main() \{ //test1 Foo\* p = new Foo(); p->i = 1; Foo f; f.i = 2; Foo \*p2 = new(p) Foo(f); cout << p2->i << endl; p2->i = 3; cout << p->i; cout << endl; delete p2; //delete p; //肯定会出错,因为重复删除了同一个空间 cout << endl; //test2 char\* str = new char\[sizeof(Foo)\]; Foo \*p3 = new(str) Foo(f); cout << p3->i << endl; return 0; \}

在上例中，Foo \*p2 = new(p) Foo(f); 意思是说在对象p的空间上，构造一个跟f一样的对象。

而Foo \*p3 = new(str) Foo(f);是在一个字符串的空间上构造的。

下面两个函数实际上事一样的，你知道么？

typedef void (\*func)(); func set\_handler1(func f) \{ func tmp = f; return tmp; \} void (\* set\_handler2(void (\*f)()))() \{ func tmp = f; return tmp; \}

对象的隐式构造

//隐式构造 class Foo \{ public: Foo(int i)\{cout << "ctr" << endl;\} Foo(const Foo& f)\{cout << "copy-ctr" << endl;\} Foo& operator=(const Foo& f)\{cout << "operator=" << endl; return \*this;\} ~Foo()\{cout << "dectr" << endl;\} \}; class Test \{ public: Foo f() \{ return 1; \} \}; void test() \{ //1 Test t; Foo f1 = t.f(); //2 Foo f2 = 1; \} int main() \{ test(); return 0; \}

这是可以运行的,也是C++支持的.

如果你不想让它这样趁你不注意,偷偷摸摸的构造了对象, 你可以在构造函数前面加上explicit.

class Foo \{ public: explicit Foo(int i)\{cout << "ctr" << endl;\} Foo(const Foo& f)\{cout << "copy-ctr" << endl;\} Foo& operator=(const Foo& f)\{cout << "operator=" << endl; return \*this;\} ~Foo()\{cout << "dectr" << endl;\} \};

这时,就会报错.

预编译指令的妙处

\#define \_B(x) \#x \#define PRINT(x, y, z) PRINT\_\#\#z(x,y) class BigInteger \{ public: BigInteger(const char \*)\{\} \}; void PRINT\_MAX(int i, int j) \{cout << (i>j?i:j) << endl;\} void PRINT\_MIN(int i, int j) \{cout << (i>j?j:i) << endl;\} void test(int i, int j) \{ //1 BigInteger b = \_B(12122222222222222222222222); cout << \_B(12122222222222222222222222) << endl; //2 PRINT(i, j, MAX); PRINT(i, j, MIN); \} int main() \{ test(1, 2); return 0; \}

你猜猜结果?

上面的\#x表示把x生成成为一个字符串.

a\#\#b是把ab连接成一个字符串.

上面的两个用法和用途,相信可以让你感到妙不可言.

结果:

12122222222222222222222222 2 1 请按任意键继续. . .