C++的技术探究

2023-11-28 22:59:10

C++深究

函数指针

double pam(int, double); // prototype

double (*pf)(int, double); // declare function pointer

pf = pam; // pf now points to the pam() function

double y = (*pf)(1, 5); // call pam() using pointer pf

内联函数

适用范围：不是递归调用的函数；函数多次被调用；

inline double square(double x) {

	return x * x;

}

函数模板

// non template function prototype

void Swap(job &a, job &b);

// template prototype

temple<class T>

void Swap(T &a, T &b);

// explicit specialization for the job type

template<> void Swap<job>(job &a, job &b);

关键字decltype

int x;	double y;

decltype(x + y) xpy; // make xpy the same type as x + y

关键字explicit

作用：防止隐式转换

class A {

private:

	string s;

public:

	A(string _s = "") : s(_s) {}

	int compare(const A& other);

};

class B {

private:

	string s;

public:

	explicit B(string _s = "") : s(_s) {}

	int compare(const B& other);

};

int main() {

	A a;

	a.compare("Valid"); // Is valid to do that

	B b;

	b.compare("InValid"); // Is invalid to do that

	return 0;

}

关键字auto

作用：自动推导变量类型

vector<int> v;

auto it = v.begin();

运算符dynamic_cast

作用：判断指针pg的类型是否被安全地转换为Superb*。如果可以，运算符将返回对象的地址，否则返回一个空指针。

class Superb : public Grand {...}

Grand *pg = new Grand;

Superb *pm = dynamic_cast<Superb*>(pg);

运算符typeid

作用：确定两个对象是否为同种类型

typeid(Grand) == typeid(*pg);

运算符const_cast

作用：删除const typename* 中的const，当且仅当指向的值的声明是非const的时候有效

void change(const int *pt, int n) {

	int *pc = const_cast<int*>(pt);

	*pc += n;

}

int pop1 = 38383;

change(&pop1, -103); // valid

const int pop2 = 2000;

change(&pop2, -103); // invalid

运算符static_cast

作用：可隐式转换的时候才生效

High bar;

Low blow;

High *pb = static_cast<High*>(&blow); // valid

Low *pl = static_cast<Low*>(&bar); // valid

Pond *pmer  = static_cast<Pond*>(&blow); // invalid

运算符reinterpret_cast

作用：天生危险的类型转换

struct dat {short a, b};

long value = 0xaaaaaaaa;

dat *pd = reinterpret_cast<dat*>(&value); // valid

智能指针auto_ptr

作用：离开作用域的时候自动调用析构函数释放动态内存

void function() {

	auto_ptr<double> ap(new double);

	*ap = 2.333;

	return;

}

智能指针shared_ptr

作用：跟踪引用特定对象的智能指针数，当最后一个指针过期时，才调用delete

智能指针unique_ptr

作用：唯一所有权(ownship)，不允许智能指针直接拷贝赋值

Lambda函数

作用：允许使用匿名函数

说明：&表示引用变量，=表示取值变量

[](int x) {return x % 3 == 0;}

bool f(int x) {return x % 3 == 0;}

[&count, =sock]() {count++;}

包装器function

作用：用作形式参数，作为一个function包装器对象

template<class T>

T use_f(T v, std::function<T(T)> f);

function<double(int, char)> f;

// 等价于

double f(int, char);

可变参数模板

作用：传递未知数量的参数

void print() {}

template<class T>

void print(T value) {

	std::cout << value << std::endl;

}

template<class T, class... Args>

void print(T value, Args... args) {

	std::cout << value << ", ";

	print(args...);

}

码农公寓