C++类型转换
C语言风格的类型转换符号
(type)expression或type(expression)。
int main()
{
double a = 1.1;
int b = (int) a;
int c = int(a);
return 0;
}
C++中有4个类型转换符号
static_cast。
dynamic_cast。
reinterpret_cast。
const_cast。
使用格式:xx_cast<type>(expression)。
const_cast
一般用于去除const属性,将const转换成非const。
class Point{};
int main()
{
const Point *p = new Point();
// Point *p2 = p; 不被允许
Point *p2 = const_cast<Point *>(p);
// 等于下面的
// Point *p2 = (Point *)p;
...
LeetCode 881. 救生艇
原题链接
题目描述
第 iii 个人的体重为 people[i],每艘船可以承载的最大重量为 limit。
每艘船最多可同时载两人,但条件是这些人的重量之和最多为 limit。
返回载到每一个人所需的最小船数。(保证每个人都能被船载)。
数据范围
1≤people.length≤500001 \le people.length \le 500001≤people.length≤50000
1≤people[i]≤limit≤300001 \le people[i] \le limit \le 300001≤people[i]≤limit≤30000
样例
输入样例1:
people = [1,2], limit = 3
输出样例1:
1
样例1解释:
111 艘船载 (1,2)(1, 2)(1,2)
输入样例2:
people = [3,2,2,1], limit = 3
输出样例2:
3
样例2解释:
333 艘船分别载 (1,2),(2)(1, 2), (2)(1,2),(2) 和 (3)(3)(3)
输入样例3:
people = [3,5,3,4], lim ...
C++模板
泛型
泛型,是一种将类型参数化以达到代码复用的技术,C+ +中使用模板来实现泛型。
模板(template)
格式:template <typename/class T>。
也可以指定多个类型,template <typename A, typename B, typename C> C add(A a, B b),在调用的时候,指定参数类型即可。
如果有调用模板,编译器会根据参数类型,生成不同的函数。没有调用就不会生成。
typename和class是等价的。
模板的声明和实现如果分离到.h和.cpp中,会导致链接错误。
template <typename T>
T add(T a, T b)
{
return a + b;
}
int main()
{
cout << add<int>(1, 2) << endl;
cout << add<double>(1.1, 2.1) << endl;
c ...
LeetCode 295. 数据流的中位数
原题链接
题目描述
思路
代码
C++
class MedianFinder {
priority_queue<int, vector<int>, greater<int>> up;
priority_queue<int> down;
public:
/** initialize your data structure here. */
MedianFinder() {
}
void addNum(int num) {
if ( down.empty() || num <= down.top() )
{
down.push(num);
if ( down.size() > up.size() + 1 )
{
up.push(down.top());
...
C++运算符重载
运算符重载(操作符重载):可以为运算符增加一些新的功能。
class Point
{
friend Point operator+(const Point &, const Point &);
private:
int x, y;
public:
int get_x() { return this->x; }
int get_y() { return this->y; }
Point(int x, int y) : x(x), y(y) { }
void display()
{
printf("(%d, %d)\n", this->x, this->y);
}
};
Point operator+(const Point &p1, const Point &p2)
{
return Point(p1.x + p2 ...
C++拷贝构造函数
拷贝构造函数的英文:Copy Constructor。
拷贝构造函数是构造函数的一种。
当利用已存在的对象创建一个新对象时(类似于拷贝),就会调用新对象的拷贝构造函数进行初始化。
拷贝构造函数的格式是固定的,接收一个const引用作为参数。
class Car
{
private:
int price;
int length;
public:
Car(int price = 0, int length = 0) : price(price), length(length) { }
// 拷贝构造函数
Car(const Car &car) : price(car.price), length(car.length)
{
printf("Car(Car &car)\n");
}
void display()
{
printf("price = %d, length = %d\ ...
C++特殊成员
静态成员(static)
被static修饰的成员变量/函数。
可以通过对象(对象.静态成员)、对象指针(对象指针->静态成员)、类访问(类名::静态成员)。
静态成员变量
静态成员变量存储在数据段(全局区,类似于全局变量),整个程序运行过程中只有一份内存。
对比全局变量,它可以设定访问权限(public、 protected、 private),达到局部共享的目的。
必须初始化,必须在类外面初始化,初始化时不能带static,如果类的声明和实现分离(在实现.cpp中初始化)。
静态成员函数
内部不能使用this指针(this指针只能用在非静态成员函数内部)。
不能是虚函数(虚函数只能是非静态成员函数)。
内部不能访问非静态成员变量/函数,只能访问静态成员变量/函数。
非静态成员函数内部可以访问静态成员变量/函数。
构造函数、析构函数不能是静态。
当声明和实现分离时,实现部分不能带static。
class Car
{
public:
static int price;
static void run()
{
...
C++中的多态
父类指针、子类指针
父类指针可以指向子类对象,是安全的。(继承方式必须是public)
子类指针指向父类对象是不安全的。
struct A
{
int a;
};
struct B : A
{
int b;
};
int main()
{
// 父类指针指向子类对象
A *a = new B();
delete a;
return 0;
}
多态
多态是面向对象非常重要的一个特性。
同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。
在运行时,可以识别出真正的对象类型,调用对应子类中的函数。
使用函数重载来实现传入不同类型的对象,调用同名的函数的,做不同的事情。
struct Dog
{
void speak()
{
printf("Dog::speack\n");
}
void run()
{
printf("D ...
C++中的继承与多继承
继承
可以让子类拥有父类的所有可访问成员(变量/函数)。
C++没有像Java的基类。
语法
在类名后面写个:再接上父类类名即可。Student : Person
struct Person
{
int id;
void run(){ }
};
struct Student : Person
{
int score;
void study() { }
};
struct Worker : Person
{
int salary;
void work() { }
};
关系描述:Person:父类(superclass,超类),Student:子类(subclass,派生类)。
内存布局:像上面的代码,Wroker这个类型的对象占用8个字节,以为父类占4个字节,自己占4个字节。父类的成员变量在前面,子类的在后面。
成员访问权限
成员访问权限、继承方式有3种
public:公共的,任何地方都可以访问(st ...
C++命名空间
可以用来避免命名冲突。
使用namespace 名字来定义一个命名空间。使用的时候,在全局变量、函数或类前面加上空间名字::即可指定命名空间。
class Person
{
private:
int age;
public:
void set_age(int);
int get_age();
};
namespace zhoupb
{
int a;
void fun() { }
class Person
{
private:
int id;
public:
Person(/* args */);
~Person();
void set_id(int id);
int get_id();
};
Person::Person(/* args */) { }
Person::~Pe ...
