C++ on Zs's Blog

C++ 类使用注意事项

Wed, 09 Nov 2022 22:40:41 +0800

前言

本文包含一些在使用 C++ 类时的注意事项，可避免一些常见问题，并能让你在写代码时更加自信。

因为目前我使用的是 C++ 17，所以仅保证以下内容在 C++ 17 中正确。

构造函数

对于单个参数的构造函数，推荐添加 explicit 关键字，防止隐式转换错误调用构造函数。

class DemoClass {
    explicit DemoClass(int test) {
        this->test_ = test;
    }
}

显式声明有参构造函数后，编译器不会自动生成无参构造函数，若需要，请添加 DemoClass() = default;

class DemoClass {
    explicit DemoClass(int test) {
        this->test_ = test;
    }
    DemoClass() = default;
}

若子类中没有显式调用父类的构造函数，子类会默认调用父类的无参构造函数，如果父类没有无参构造函数，会报错。

析构函数

基类析构函数应该声明为 virtual，这样可以防止子类无法正确的析构。
由于基类析构函数为 virtual，派生类的析构函数应该显式的 override。

class DemoClass {
    virtual ~DemoClass() = default;
}

class ChildClass: public DemoClass {
    ~ChildClass() override {
        xxx;
    }
}

成员变量默认值

对于类或局部作用域中未明确指定默认值的成员变量，其值遵循以下规则：

对于原生类型（primitive types），即 int、float、int*、string* 等，默认值为随机的脏数据。
对于对象（objects），例如自定义类、或 std::string 等，会调用默认（无参）构造函数，若没有默认（无参）构造函数，则报错。
对于引用（reference）类型，例如 std::string&，必须赋初始值或在构造函数中初始化，若为初始化，则报错。

float age; // 脏数据、随机值（无意义），此时访问会出现未定义行为
int *ptr;  // 脏数据、随机值（无意义），此时访问会出现未定义行为
string name;  // 调用默认构造函数，对于 std::string 来说为空字符串 ""
DemoClass demo; // 若 DemoClass 存在无参构造函数，则调用，否则编译错误
string *pname;  // 脏数据、随机值（无意义），此时访问会出现未定义行为
string &rname;  // 编译错误，必须显式初始化
const string &crname;  // 同上，编译错误

成员变量初始化方式

初始化成员变量一般而言有四种方式，一般而言第二种和第四种方式为等价的，不过在下面我们会看到一种例外：

class DemoClass {
    int a = 1; // (1) 通过 a == 1
    int a{1};  // (2) 通过 a == 1
    int a(1);  // (3) 报错，只能用于对对象的初始化
    int a = {1}; // (4)通过 a == 1
}

总体而言，推荐使用第二种方式，更加通用、现代、安全。

只不过在使用存在以 std::initializer_list 为参数做初始化的对象时，推荐使用第三种方式，第二种方式会导致非常贪婪的构造调用，详情可见：Item 7:区别使用()和{}创建对象 - Effective Modern C++

同时，对于某些对象，例如 std::vector，第二种方式与第三种方式存在区别，此时要根据使用意图区别调用：

std::vector vec(10, 20); // vec 包含 10 个元素，值均为 20
std::vector vec{10, 20};  // vec 包含 10, 20 两个元素

此外，在 C++17 之前，在搭配使用 auto 和 {} 时会产生奇怪的行为，同时在这里带 = 和不带 = 的 {} 会出现差别：

auto a{1};  // C++17 之前 a 为 std::initializer_list<int>，之后为 int
auto a = {1}; // a 为 std::initializer_list<int>
auto a = 1; // a 为 int
auto a{1, 2};  // 报错!
auto a = {1, 2}; // a 为 std::initializer_list<int>

更进一步

为什么推荐使用第二种方式？

C++11 引入了 {} 这种称为统一初始化（uniform initialization）的语法来整合那些混乱且不适于所有情景的初始化语法。

为什么叫统一初始化？看以下几个例子：

class DemoClass{
    …
    
private:
    int x{ 0 };   //没问题，x初始值为0
    int y = 0;    //也可以
    int z(0);     //错误！
}

这里，z 为一个原生类型，而不是对象，无法使用 () 来对其初始化。

而 = 也不是总是可用的，不可赋值拷贝构造的对象（例如std::atomic——见Item40）可以使用花括号初始化或者小括号初始化，但是不能使用 = 初始化：

std::atomic<int> ai1{ 0 };      //没问题
std::atomic<int> ai2(0);        //没问题
std::atomic<int> ai3 = 0;       //错误！

因此我们很容易理解为什么 {} 初始化又叫统一初始化，在 C++ 中这三种方式都被指派为初始化表达式（而不是什么函数声明或者拷贝构造），但是只有 {} 任何地方都能被使用。

参考资料及拓展阅读资料

为什么要使用条件变量？

Wed, 24 Aug 2022 23:37:00 +0000

为什么要使用条件变量？

前言

最近看了很多与线程有关的 C++ 新特性，条件变量是见的比较多的一个特性。

看的时候我发现，想要理解一个新的特性，关键的要看它的引入到底解决了哪些问题，没有什么特性我们要实现相同的功能要怎么做？

以我的理解来看，条件变量是一个线程间互相同步与通知的手段，他通过主动唤醒的方式减小了各个线程的开销，取代了简单但是消耗较大的一直被动循环检验与等待。

没有条件变量我们如何实现相同的需求？

这里采用现代C++教程¹ 中关于条件变量的一个例子作为基础：

不使用条件变量版本

#include <queue>
#include <chrono>
#include <mutex>
#include <thread>
#include <iostream>
#include <condition_variable>


int main() {
    std::queue<int> produced_nums;
    std::mutex mtx;

    // 生产者
    auto producer = [&]() {
        for (int i = 0; ; i++) {
            std::this_thread::sleep_for(std::chrono::milliseconds(900));
            std::unique_lock<std::mutex> lock(mtx);
            std::cout << "producing " << i << std::endl;
            produced_nums.push(i);
        }
    };
    // 消费者
    auto consumer = [&]() {
        while (true) {
            {
              std::unique_lock<std::mutex> lock(mtx);
              if(produced_nums.empty()) continue;
            }
            std::unique_lock<std::mutex> lock(mtx);
            // 短暂取消锁，使得生产者有机会在消费者消费空前继续生产
            lock.unlock();
            // 消费者慢于生产者
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
            lock.lock();
            while (!produced_nums.empty()) {
                std::cout << "consuming " << produced_nums.front() << std::endl;
                produced_nums.pop();
            }
        }
    };

    // 分别在不同的线程中运行
    std::thread p(producer);
    std::thread cs[2];
    for (int i = 0; i < 2; ++i) {
        cs[i] = std::thread(consumer);
    }
    p.join();
    for (int i = 0; i < 2; ++i) {
        cs[i].join();
    }
    return 0;
}

使用条件变量版本

#include <queue>
#include <chrono>
#include <mutex>
#include <thread>
#include <iostream>
#include <condition_variable>


int main() {
    std::queue<int> produced_nums;
    std::mutex mtx;
    std::condition_variable cv;
    bool notified = false;  // 通知信号

    // 生产者
    auto producer = [&]() {
        for (int i = 0; ; i++) {
            std::this_thread::sleep_for(std::chrono::milliseconds(900));
            std::unique_lock<std::mutex> lock(mtx);
            std::cout << "producing " << i << std::endl;
            produced_nums.push(i);
            notified = true;
            cv.notify_all(); // 此处也可以使用 notify_one
        }
    };
    // 消费者
    auto consumer = [&]() {
        while (true) {
            std::unique_lock<std::mutex> lock(mtx);
            while (!notified) {  // 避免虚假唤醒
                cv.wait(lock);
            }
            // 短暂取消锁，使得生产者有机会在消费者消费空前继续生产
            lock.unlock();
            // 消费者慢于生产者
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
            lock.lock();
            while (!produced_nums.empty()) {
                std::cout << "consuming " << produced_nums.front() << std::endl;
                produced_nums.pop();
            }
            notified = false;
        }
    };

    // 分别在不同的线程中运行
    std::thread p(producer);
    std::thread cs[2];
    for (int i = 0; i < 2; ++i) {
        cs[i] = std::thread(consumer);
    }
    p.join();
    for (int i = 0; i < 2; ++i) {
        cs[i].join();
    }
    return 0;
}

这两段代码在效果上是等效的，都是一个生产者两个消费者。

前者使用了 while 循环来一直检查是否可以消费，后者使用了 cv.wait(lock) 条件变量来实现阻塞等待可消费的提醒。

可以发现在这个例子里，前者是主动的去检查是否可以消费，后者是被动的被提醒可以消费，而主动则代表着需要一直询问查询，主动的 while 循环检查始终在重复如下流程：

而这个上锁、检查、释放锁的过程就是非常冗余、消耗资源、效率低下的，而条件变量解决了这个问题，条件变量做的事：

这里需要注意的一点是，在条件变量调用 wait() 时，做了两件事，一个是阻塞线程等待其他线程唤醒、另一个是释放锁，只有这样才会让别的线程有机会获得锁，而被唤醒后又会自动上锁。

为什么要和 mutex 与 lock 一起用？

我们常见的搭配就是 condition_variable、mutex、unique_lock 一起使用，那么为什么要这么做呢？

一个比较常见的说法是，在调用 wait() 函数与线程真正的阻塞等待状态是存在一定时间差的，那么就会存在唤醒丢失的问题，一种情况如下：

线程A： ------- 调用 wait() 函数 ------- 进入等待状态 ------

线程B： -------------------------唤醒A-------------------

而我们希望的是：

线程A： ------- 调用 wait() 函数 ------- 进入等待状态 ------

线程B： -------------------------------------------唤醒A-

我们总是要确保，在线程 A 真正进入等待状态后再进行唤醒，因此这里需要一个 lock 来保证我们对于一个线程空闲/等待的改变是原子性的，也就是不应该被其他线程中途干扰。

为什么使用 unique_lock 而不使用 scoped_lock 或 lock_guard

首先三个函数都是 RAII 的锁管理函数，可以有效解决 lock 后忘记 unlock 的情形，而目前在 C++17 后推荐统一使用 scoped_lock 而不是 lock_guard。

而使用 unique_lock 是因为我们在使用条件变量时，需要在条件变量 wait 时解除 lock，只有 unique_lock 能够满足这个条件，实现自己更细粒度的锁区间的划分。

什么是虚假唤醒？

可以注意到在第一部分代码中有这么一段：

auto consumer = [&]() {
        while (true) {
            std::unique_lock<std::mutex> lock(mtx);
            while (!notified) {  // 避免虚假唤醒
                cv.wait(lock);
            }
            // ...
            notified = false;
        }
    };

避免虚假唤醒，那么什么是虚假唤醒呢？

虚假唤醒简而言之就是，没有满足消费的条件却被唤醒后进行了消费。

这个发生的可能多是在系统调度层面，具体的可以参考此知乎问题：为什么条件锁会产生虚假唤醒现象（spurious wakeup）？

而解决的方案就是在消费之前再检查一下是否满足消费的条件，而这个消费条件多是用一个形如 notified 的 bool 变量来标识是否可以消费。

如果不检查，带条件变量的执行流程就会像如下这样：

其中少了一步检查是否可以消费的过程。

后记

本文记录了我在学习条件变量过程中的一些疑问，如有错误之处，敬请交流指正。

https://changkun.de/modern-cpp/ ↩︎

C++大数类的实现

Mon, 06 Apr 2020 01:22:00 +0000

C++大数类设计思路

洛谷大数类的评测结果(开了氧气优化)

这个第四个点真的优化不过去了QAQ，24W的数据，~~丧心病狂~~

整体构思

构造大数类名为 BigNumber ,首先想法是用字符串读入大数，然后将其转化为vector数组倒序分位存储的整数，然后通过一个 len 来记录数字的位数，便于做运算。还设计了一个标记变量，用于标记这数为正数还是负数。

构造函数

我用了两种构造函数，一个是无参构造函数，一个是拷贝构造函数，当然还有一个有参构造函数，但是实际过程中我没有用到。无参构造函数用于上述类成员的初始化，拷贝构造函数用于复制一个相同的大数类进行运算。有参构造函数可以用于对类成员的复制。

重载运算符

重载 “+”

首先在类中进行了声明, BigNumber operator + (const BigNumber &b); ，用当前类 *this 来和引入的类 b 进行加法运算，返回值为一个 BigNumber 类。
在类的外部进行重载的定义，先将用拷贝构造函数将当前的类 *this 拷贝为 a ，然后对 a 和 b 进行加法运算，模拟竖式，对应位相加，大于10则进位，最后去掉尾部的 0 即可。

BigNumber BigNumber::operator + (const BigNumber &b) //重载 "+" 定义 
{
    
	BigNumber Result;
	BigNumber a(*this);
	Result.len = max(a.len,b.len)+1;
	int add=0;
	for(int i=0;i<Result.len||add!=0;i++)
	{
		int p=add;
		if(i<a.len) p+=a.v[i];
		if(i<b.len) p+=b.v[i];
		add=p/10;
		Result.v.push_back(p%10);
	}
	while(Result.v[Result.v.size()-1]==0 && Result.v.size() > 1)
	{
		Result.v.pop_back();
	}
	Result.len=Result.v.size();
	return Result;
    
}

重载 “<”

因为进行减法前需要比较两个大数类的大小，我就先重载了 < 。思路就是先比较a、b两个大数的长度，长的那个肯定比较大，如果两个长度相等。从尾部开始依次向前比较，如果不相等的话，就看两个数的相对大小，大的那个肯定整体比较大。如果总是相等，到了最后，就返回相应的值表示他们相等。这里我的返回值为int类型，用的标记是：如果两个相等，返回-1，如果前者小于后者，返回1，如果前者大于后者，返回0.

int  BigNumber::operator < (const BigNumber &b) // 重载 "<" 定义 
{
	BigNumber a(*this);
	
	if(a.len < b.len) return 1;
	if(a.len > b.len) return 0;
	
	for(int i=a.len-1;i>=0;i--)
	{
		if(a.v[i]!=b.v[i])
		{
			return a.v[i] < b.v[i];
		}
	}
	return -1;
}

重载 “-”

首先在类中进行了声明, BigNumber operator - (BigNumber &b); ，用当前类 *this 来和引入的类 b 进行减法运算，返回值为一个 BigNumber 类。
在类的外部进行重载的定义，先将用拷贝构造函数将当前的类 *this 拷贝为 a ，然后对 a 和 b 进行减法运算。如果 a<b ，那么我们就把 flag 设为 true ，标志得数为一个负数，然后用 swap 交换两个类，保证总是大数减小数。减法的话就是从前往后扫，对应位相减，如果不够减的就进行借位。如果借完位当前位置小于0了，那么就再向前借位。最后要去掉结尾多于的0.

BigNumber BigNumber::operator - (BigNumber &b) // 重载 "-" 定义 
{
	BigNumber Result;
	BigNumber a(*this);
	if(a<b==1)
	{
		swap(a,b);
		Result.flag=true;
	}
	Result.len=a.len;
	for(int i=0;i<a.len;i++)
	{
		if(a.v[i]<0)
		{
			a.v[i]+=10;
			a.v[i+1]--;
		} 
		if(a.v[i] < b.v[i]&&i<b.len)
		{
			a.v[i]+=10;
			a.v[i+1]--;
		}
		if(i<b.len)
		Result.v.push_back(a.v[i]-b.v[i]);
		else Result.v.push_back(a.v[i]);
	}
	while(Result.v[Result.len-1]==0 && Result.len > 1)
	{
		Result.v.pop_back();
		Result.len--;
	}
	return Result;
}

重载 “*”

首先在类中进行了声明, BigNumber operator * (BigNumber &b);，用当前类 *this 来和引入的类 b 进行乘法运算，返回值为一个 BigNumber 类。
在类的外部进行重载的定义，先将用拷贝构造函数将当前的类 *this 拷贝为 a ，然后对 a 和 b 进行乘法运算。乘法也是模拟竖式运算，两个位数相乘对应的得数中的哪一位不难发现，因此只需要边乘边进位即可，一开始想的是所有乘完之后再进位，后来想了想运算的次序不会影响除和模的运算，所以就可以边乘边取商和模，可以少掉两层循环。算是一个小小的优化。最后要去掉结尾多于的0.

BigNumber BigNumber::operator * (BigNumber &b) // 重载 "*"  定义 
{
	BigNumber Result;
	BigNumber a(*this);
	Result.len=a.len+b.len;
	for(int i=0;i<Result.len;i++) Result.v.push_back(0);
	for(int i=0;i<a.len;i++)
	{
		for(int j=0;j<b.len;j++)
		{
			Result.v[i+j]+=a.v[i]*b.v[j];
			Result.v[i+j+1]+=Result.v[i+j]/10;
			Result.v[i+j]%=10;
		}
	}
	while(Result.v[Result.v.size()-1]==0 && Result.v.size() > 1)
	{
		Result.v.pop_back();
	}
	Result.len=Result.v.size();
	return Result;
}

重载 “/”

首先在类中进行了声明,BigNumber operator / (BigNumber &b);，用当前类 *this 来和引入的类 b 进行除法运算，返回值为一个 BigNumber 类。
在类的外部进行重载的定义，先将用拷贝构造函数将当前的类 *this 拷贝为 a ，然后对 a 和 b 进行除法法运算。我选择了做除法的时候大数类中同时存储商和余数，这样可以加快效率，因为我自己的想法是把除法和取模一起处理，求得商的同时，模也能求出来。因此他们的框架肯定是相差无几的，所以我选择了一次性算出来两个，在大数类中用两个vector数组分别存商和余数，求商和余数我用的是减法的策略，分下面三种情况来讨论
- a<b ：很显然商为0，余数为a。
- a==b ：很显然商为1，余数为0。
- a>b ：这个是最难处理的，我们想想一下模拟除法的竖式运算，先在b的后面填0，让a和b的位数相同，然后再一直对a进行减法运算，将得到的数排列起来即可。里面细节还是挺多的，具体的看代码。最后要去掉结尾多于的0.

BigNumber BigNumber::operator / (BigNumber &b) // 重载 "/" 定义 
{
	BigNumber Result;
	BigNumber a(*this);
	if(a<b==1)
	{
		Result.v.push_back(0);
		for(int i=0;i<a.v.size();i++)
		{
			Result.m.push_back(a.v[i]);
		}
		return Result;
	}
	if(a<b==-1)
	{
		Result.v.push_back(1);
		Result.m.push_back(0);
		Result.len=1;
	}
	if(a<b==0)
	{
		int size = a.len-b.len;
		for(int i=size;i>=0;i--)
		{
			BigNumber p(b);
			int cnt=0;
			for(int j=1;j<=i;j++)
			{
				p.v.insert(p.v.begin(),0);
			}
			p.len = p.v.size();
			while((a-p).flag==false)
			{
				a=a-p;
				cnt++;
			}
			if(i==size)
			{
				for(int j=1;j<=size;j++)
				{
					Result.v.push_back(0);
				}
				Result.v.push_back(cnt);
			}
			else
			{
				Result.v[i] = cnt;
			}
		}
		while(Result.v[Result.v.size()-1]==0 && Result.v.size() > 1)
		{
			Result.v.pop_back();
		}
		Result.len=Result.v.size();
		for(int i=0;i<a.v.size();i++)
		{
			Result.m.push_back(a.v[i]);
		}
	}
	return Result;
}

重载 “%”

这个和除法的类似，我们除法的其实已经求出来模了，这个只是象征性的搞一搞。QAQ。

BigNumber BigNumber::operator % (BigNumber &b) //重载 "%" 定义 
{
	BigNumber Result;
	BigNumber a(*this);
	if(a<b)
	{
		Result.v.push_back(0);
		return Result;
	}
	else
	{
		int size = a.len-b.len;
		for(int i=size;i>=0;i--)
		{
			BigNumber p(b);
			for(int j=1;j<=i;j++)
			{
				p.v.insert(p.v.begin(),0);
			}
			p.len = p.v.size();
			while((a-p).flag==false)
			{
				a=a-p;
			}
		}
		for(int i=0;i<a.v.size();i++)
		{
			Result.v.push_back(a.v[i]);
		}
	}
	return Result;
}

其中遇到的问题

在做减法的时候，会出现莫名奇怪的数据，后来发现是由于访问b数组的时候越界，而且vector数组的clear只是将数组的size置为了0，而不是将所有数据都莫抹除，而且vector通过下标访问越界还不会报错，我整个人都傻了，调了巨长时间。
在做除法的时候，一度自闭。本来是只是一直减，这样效率真的巨tm慢。后来想到了用这个办法好像可以优化到 log 级别的，但是好难调试啊。。从昨天下午一直搞到现在。
因为swap这个东西，好像会影响到类的源数据，所以我就多定义了几个数，分别对他们进行操作，这样就不会相互影响，虽然看起来挺丑的。

整体的代码实现

/*
	Name: BigNumber Class
	Copyright: Zs
	Author: Zs
	Date: 04/04/20 09:08
	Description: A BigNumber Class
*/

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<vector>

using namespace std;

class BigNumber
{
	private:
		vector<int> v; // 和，差，积，商 
		vector<int> m; // 余数，当无余数的时候 size 为0 
		int len;  // 数字的长度 = v.size() 
		bool flag; //是否为负数的标志 
	public:
		BigNumber();//无参构造函数 
		BigNumber(string s)  //带参数的构造函数 
		{
			*this=s;
		}
		BigNumber(const BigNumber &); // 拷贝构造函数 
		BigNumber operator = (const string s);  // 重载 "=" 声明 
		BigNumber operator = (int k);  // 重载输入的数为整型的时候的 "=" 声明
		
		int operator < (const BigNumber &b);  // 重载 "<" 声明 
		BigNumber operator + (const BigNumber &b); // 重载 "+" 声明 
		BigNumber operator - (BigNumber &b); // 重载 "-" 声明 
		BigNumber operator * (BigNumber &b);  // 重载 "*" 声明 
		BigNumber operator / (BigNumber &b); //重载 "/" 声明 
		BigNumber operator % (BigNumber &b); //重载 "%" 声明 
		
		void print() //输出函数 
		{
			if(flag)
			{
				printf("-");
				flag=false;
			}
			for(int i=v.size()-1;i>=0;i--) printf("%d",v[i]);
			printf("\n");
			for(int i=m.size()-1;i>=0;i--) printf("%d",m[i]);
		}
		
};

BigNumber::BigNumber() //无参构造函数 
{
	v.clear();
	m.clear();
	len = 0;
	flag=false;
}
BigNumber::BigNumber(const BigNumber &T) // 拷贝构造函数 
{
	v.assign(T.v.begin(),T.v.end());
	len = T.len;
	flag = T.flag;
}

BigNumber BigNumber::operator = (const string s) // 重载 "=" 定义 
{
	len = s.length();
	for(int i=0;i<len;i++)
	{
		v.push_back(s[len-1-i]-'0');
	}
	return *this;
}
BigNumber BigNumber::operator = (int k) // 重载输入的数为整型的时候的 "=" 定义 
{
	while(k)
	{
		v.push_back(k%10);
		k/=10;
		len++; 
	}
	len--;
	return *this;
}

int  BigNumber::operator < (const BigNumber &b) // 重载 "<" 定义 
{
	BigNumber a(*this);
	
	if(a.len < b.len) return 1;
	if(a.len > b.len) return 0;
	
	for(int i=a.len-1;i>=0;i--)
	{
		if(a.v[i]!=b.v[i])
		{
			return a.v[i] < b.v[i];
		}
	}
	return -1;
}
BigNumber BigNumber::operator + (const BigNumber &b) //重载 "+" 定义 
{
	
	BigNumber Result;
	BigNumber a(*this);
	Result.len = max(a.len,b.len)+1;
	int add=0;
	for(int i=0;i<Result.len||add!=0;i++)
	{
		int p=add;
		if(i<a.len) p+=a.v[i];
		if(i<b.len) p+=b.v[i];
		add=p/10;
		Result.v.push_back(p%10);
	}
	while(Result.v[Result.v.size()-1]==0 && Result.v.size() > 1)
	{
		Result.v.pop_back();
	}
	Result.len=Result.v.size();
	return Result;
	
}
BigNumber BigNumber::operator - (BigNumber &b) // 重载 "-" 定义 
{
	BigNumber Result;
	BigNumber a(*this);
	if(a<b==1)
	{
		swap(a,b);
		Result.flag=true;
	}
	Result.len=a.len;
	for(int i=0;i<a.len;i++)
	{
		if(a.v[i]<0)
		{
			a.v[i]+=10;
			a.v[i+1]--;
		} 
		if(a.v[i] < b.v[i]&&i<b.len)
		{
			a.v[i]+=10;
			a.v[i+1]--;
		}
		if(i<b.len)
		Result.v.push_back(a.v[i]-b.v[i]);
		else Result.v.push_back(a.v[i]);
	}
	while(Result.v[Result.len-1]==0 && Result.len > 1)
	{
		Result.v.pop_back();
		Result.len--;
	}
	return Result;
}

BigNumber BigNumber::operator * (BigNumber &b) // 重载 "*"  定义 
{
	BigNumber Result;
	BigNumber a(*this);
	Result.len=a.len+b.len;
	for(int i=0;i<Result.len;i++) Result.v.push_back(0);
	for(int i=0;i<a.len;i++)
	{
		for(int j=0;j<b.len;j++)
		{
			Result.v[i+j]+=a.v[i]*b.v[j];
			Result.v[i+j+1]+=Result.v[i+j]/10;
			Result.v[i+j]%=10;
		}
	}
	while(Result.v[Result.v.size()-1]==0 && Result.v.size() > 1)
	{
		Result.v.pop_back();
	}
	Result.len=Result.v.size();
	return Result;
}

BigNumber BigNumber::operator / (BigNumber &b) // 重载 "/" 定义 
{
	BigNumber Result;
	BigNumber a(*this);
	if(a<b==1)
	{
		Result.v.push_back(0);
		for(int i=0;i<a.v.size();i++)
		{
			Result.m.push_back(a.v[i]);
		}
		return Result;
	}
	if(a<b==-1)
	{
		Result.v.push_back(1);
		Result.m.push_back(0);
		Result.len=1;
	}
	if(a<b==0)
	{
		int size = a.len-b.len;
		for(int i=size;i>=0;i--)
		{
			BigNumber p(b);
			int cnt=0;
			for(int j=1;j<=i;j++)
			{
				p.v.insert(p.v.begin(),0);
			}
			p.len = p.v.size();
			while((a-p).flag==false)
			{
				a=a-p;
				cnt++;
			}
			if(i==size)
			{
				for(int j=1;j<=size;j++)
				{
					Result.v.push_back(0);
				}
				Result.v.push_back(cnt);
			}
			else
			{
				Result.v[i] = cnt;
			}
		}
		while(Result.v[Result.v.size()-1]==0 && Result.v.size() > 1)
		{
			Result.v.pop_back();
		}
		Result.len=Result.v.size();
		for(int i=0;i<a.v.size();i++)
		{
			Result.m.push_back(a.v[i]);
		}
	}
	return Result;
}
BigNumber BigNumber::operator % (BigNumber &b) //重载 "%" 定义 
{
	BigNumber Result;
	BigNumber a(*this);
	if(a<b)
	{
		Result.v.push_back(0);
		return Result;
	}
	else
	{
		int size = a.len-b.len;
		for(int i=size;i>=0;i--)
		{
			BigNumber p(b);
			for(int j=1;j<=i;j++)
			{
				p.v.insert(p.v.begin(),0);
			}
			p.len = p.v.size();
			while((a-p).flag==false)
			{
				a=a-p;
			}
		}
		for(int i=0;i<a.v.size();i++)
		{
			Result.v.push_back(a.v[i]);
		}
	}
	return Result;
} 
int main()
{
//	freopen("test.in","r",stdin);
//	freopen("test.out","w",stdout);
	string s1,s2;
	cin>>s1>>s2;
	BigNumber a,b,c,e,f,k,j;
	a=s1,b=s2;
	e=s1,f=s2;
	k=s1,j=s2;
	c=a+b;
	c.print();
	c=a-b;
	c.print();
	c=k*j;
	c.print();
	c=e%f;
	c.print();
	return 0;
}