C++学习记录——유 类和对象（3）

news2025/6/7 11:11:48

文章目录

  • 1、赋值运算符重载
    • 1、运算符重载
      • 1、理解
      • 2、运算符重载实例
    • 2、赋值运算符重载
  • 2、日期类的实现
    • 1、加减函数
      • 1、加函数
      • 2、减函数
    • 2、前/后置++--重载
    • 3.两个日期相减
  • 其他
    • 1、流插入
    • 2、流提取

日期类的整体实现代码: https://gitee.com/kongqizyd/start-some-c-codes-for-learning.c/tree/master/%E6%97%A5%E6%9C%9F%E7%B1%BB

关于日期类的讲解会比较长，可以边看完整代码边看分析

1、赋值运算符重载

1、运算符重载

1、理解

继续用日期类做例子。

class Date
{
public:
	Date(int year = 2023, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

假设现在要比较两个日期数值大小

int main()
{
	Date d1(2023, 2, 8);
	Date d2;
	return 0;
}

我们自然可以定义一个函数，参数类型就是Date类或者说Date的引用类，用来比较两个变量。但这样有些俗套了，或者说很常见的做法，C++有自定义类型和内置类型，内置类型的比较很简单，而自定义类型的比较需要程序员自己确定如何比较。C++对此有运算符重载函数，用到关键字operator。现在写一个比较相等的函数。

bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}

要把他当做一个正常的函数，并且d1和d2的位置也就是在main调用这个函数时的位置，d1 == d2即可调用。这里先把三个变量变成公有类型才能在外部访问。

d1 == d2;
operator==(d1, d2);

调用时这两种写法都可，不过第一个更简单。第一个对于程序，会及时地转换成operator==(d1, d2)。

但是如果想打印结果，不能用d1 == 2，因为实际写出来时，<< >>运算符优先级高于等于号，所以需要括起来。

现在是把这个函数放到全局里，所以类里的成员变量要换成公有的才行。而另一个办法就是把这个函数放到类里面也可，但如果直接放进去编译器就会告诉你参数放多了，因为本身是有this指针的，所以括号里放一个参数即可。

	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}

调用时这样写就行

cout << d1.operator==(d2) << endl;

运算重载特征：
不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出
现。

2、运算符重载实例

写一下小于的函数。

	bool operator<(const Date& d)
	{
		if (_year < d._year)
			return true;
		else if (_year == d._year && _month < d._month)
			return true;
		else if (_year == d._year && _month == d._month && _day < d._day)
			return true;
		else
			return false;

当然也可以放到一块，直接就是return一串代码。

cout << d1.operator<(d2) << endl;

这样就可以检验一下结果。

不过我们还有一个更简单地写法。比如写小于等于的函数

	bool operator<=(const Date& d)
	{
		return *this < d || *this == d;
	}

大于等于

	bool operator>=(const Date& d)
	{
		return !(*this < d);
	}

不能出现*this > d，编译器会报出一堆错。

在这里插入图片描述

2、赋值运算符重载

现在要把d2的值赋值给d1.

	void operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

这里不用引用也可以，因为我们写好的拷贝构造函数是一个成熟的函数，用引用传参，而这里传参，调用完拷贝构造就好了，不过用一下引用能省点编译器工作。

但是这样不是赋值的完整函数。在C语言中，我们可以连续赋值，也就是x = y = z，如果按照这样写，一定会出错。这里的实现思路就是z赋值给y后要返回一个值，返回的这个值再赋值给x，这个返回值其实也就是y。

	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

还有一个问题，有可能会出现自己给自己赋值，所以加个判断。

		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}

如果不写重载，编译器还是会自己生成，规则还是一样，有资源申请才需要自己写。

拷贝构造会这样写：
Date d2 = d1;
Date d2(d1);

重载需要一个Date类型的变量，而拷贝构造可以不需要，所以重载不能这样写，Date d2 = d1。

2、日期类的实现

现在写一个比较全的日期类。

<Date.h>

#pragma once
#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year = 2023, int month = 1, int day = 1);

	void Print();

	bool operator==(const Date& d);
	bool operator!=(const Date& d);
	bool operator<(const Date& d);
	bool operator<=(const Date& d);
	bool operator>=(const Date& d);
    bool operator>(const Date& d);

	//Date& operator=(const Date& d);

private:
	int _year;
	int _month;
	int _day;
};

<Date.cpp>

#include "Date.h"

Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "/" << _month << "/" << _day << endl;
}

bool Date::operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

bool Date::operator<(const Date& d)
{
	if (_year < d._year)
		return true;
	else if (_year == d._year && _month < d._month)
		return true;
	else if (_year == d._year && _month == d._month && _day < d._day)
		return true;
	else
		return false;
}

bool Date::operator<=(const Date& d)
{
	return *this < d || *this == d;
}

bool Date::operator>=(const Date& d)
{
	return !(*this < d);
}

bool Date::operator>(const Date& d)
{
	return !(*this <= d);
}

bool Date::operator!=(const Date& d)
{
	return !(*this == d);
}

<Test.cpp>

#include "Date.h"

void Test1()
{
	Date d1(2023, 2, 8);
	d1.Print();

	Date d2(2023, 2, 28);
	d2.Print();
}

int main()
{
	Test1();
	return 0;
}

针对初始化日期的函数，有一个现实问题没有想到，就是如果年是负数呢？或者其它数是一个不可能的数呢？所以要加上检查函数，比如上一篇的我GetDay等函数。

int GetMonthDay(int year, int month)
{
	int monthArr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 ,31 };
	if (month == 2 && year % ((4 == 0 && year % 100 != 0) || (year % 400) == 0))
	{
		return 29;
	}
	else
	{
		return monthArr[month];
	}
}

Date::Date(int year, int month, int day)
{
	if (month > 0 && month < 13 && (day > 0 && day <= GetMonthDay(year, month)))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
		cout << "日期非法" << endl;
}

1、加减函数

1、加函数

写上相加的函数，这里的思路也和上一篇一样，有了返回值，+=也可以连续+=。如果这样写：Date d2 = d1 += 100，是会把d1也给改变。

Date& Date::operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if(_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

	Date d2 = d1;
	d2 += 100;
	d2.Print();
	d1.Print();

再写上+。

Date Date::operator+(int day)
{
	Date tmp(*this);
	tmp._day += day;
	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
	{
		tmp._day -= GetMonthDay(tmp._year, tmp._month);
		tmp._month++;
		if (tmp._month == 13)
		{
			++_year;
			tmp._month = 1;
		}
	}
	return tmp;
}


	Date d3 = d1 + 100;
	d3.Print();
	d1.Print();

用临时变量tmp，防止d1被改变。

出了作用域，*this存在，所以可以用引用，而tmp不存在，不能用引用。也可以在tmp前加上static，也不能用引用，d1为最一开始的数据，d2 = d1 + 100，没有问题，但是同样的，静态区里的这个tmp没有清除，它会接着上一次数据继续加，所以后面再来个d3 = d1 + 100就不是正确数据了。静态变量只会初始化一次，所以再次调用就不会被初始化。

+=和+的代码有些像，我们简化一下

Date Date::operator+(int day)
{
	Date tmp(*this);
	tmp += day;
	/*tmp._day += day;
	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
	{
		tmp._day -= GetMonthDay(tmp._year, tmp._month);
		tmp._month++;
		if (tmp._month == 13)
		{
			++_year;
			tmp._month = 1;
		}
	}*/
	return tmp;
}

+里面用+=。+=也可以使用+。

*this = *this + day;

不过实现+=，+里面放+=更好。因为+本身有拷贝，*this = *this + day还会有赋值。

2、减函数

减去天数，我们要往前倒月，倒年，先把年或者月给减好，然后再去获取天数。

Date& Date::operator-=(int day)
{
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

Date Date::operator-(int day)
{
	Date tmp(*this);
	tmp -= day;
}

加减函数齐全后，有些问题就可以解决。d2 += -100，如果还是之前的代码，那么最终的结果不切实际，转换一下就是d2 -= 100，所以在每个函数开头，我们还需要加上判断。

Date& Date::operator+=(int day)
{
	//*this = *this + day;
	if (day < 0)
	{
		*this -= -day;
		return *this;
	}
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if(_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

另外三个也是如此。

2、前/后置+±-重载

前置++比较简单，可以用引用，传入数据后+1，然后返回即可。

Date& Date::operator++()
{
	*this += 1;
	return *this;
}

后置++需要注意些，我们要返回一个+1之前的值，所以需要调用拷贝构造，创建一个临时变量。

Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}

至于编译器如何辨别是前还是后，这自有办法，不过为了构成重载，声明的时候后置会在括号里写上int，不必写变量名，仅供编译器区分用。实际比较起来，前置++还是更简单，不需要调用其他，一般情况下前置++用得比较多。

	Date& operator++();//前置++
	Date operator++(int);//后置++，int只是为了占位，和前置函数构成重载

void Test2()
{
	Date d1(2023, 2, 8);
	d1.Print();
	++d1;//前置正常++
	d1++;//后置会传一个形参类型的参数
}

–是这样写

Date& Date::operator--()
{
	*this -= 1;
	return *this;
}

Date Date::operator--(int)
{
	Date tmp(*this);
	*this -= 1;
	return tmp;
}

测试的时候可以显式调用

d1.operator++(0);

3.两个日期相减

用int类型的减函数。

声明：int operator-(const Date& d);

int Date::operator-(const Date& d)
{
	Date max = *this;
	Date min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}

测试代码

void Test5()
{
	Date d1(2023, 2, 8);
	d1.Print();

	Date d2(2002, 8, 4);
	d2.Print();

	cout << d1 - d2 << endl;
}

其他

1、流插入

像上面的Print函数，可不可cout打印呢？Print函数里是用cout实现的，那么可不可以直接cout << d1？实际上不行，但如果后面跟的是一个内置类型的变量，cout就可以了。C++有osream这个类，类里有cout等成员函数，但和默认成员函数不同，它们即使不写也有默认的函数，而其他成员函数就必须要写，ostream类已经写好了常用变量类型的函数重载，并且也写了<<的运算符重载，所以我们在用cout打印时不需要担心类型，因为C++已经写好了。

那么我们想用cout打印自定义类型的数据，那就需要自己写，写到自己的类里。

void Date::operator<<(ostream& out)
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}

这样写出来，括号还是有两个参数，但是第一个参数是默认的*this，也就是外部声明的d1这些变量。运算符重载写的时候，要按照参数顺序写，所以最后就是d1 << cout。这样有些奇怪，不是我们平常见到的那样，那么把他从类里拿出来写就可以控制顺序了，但这样就会有一个问题，成员变量无法访问，除去把他们变公有外，还可以添加友元函数。

声明：void operator<<(ostream& out, const Date& d);

类里这样写

	//友元
	friend void operator<<(ostream& out, const Date& d);

定义：

void operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
}

测试代码

	operator<<(cout, d1);
	cout << d1;

平常写流插入的时候很多都是连续写，所以还需要改进，要有返回值。

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

2、流提取

流提取的参数不能加const，加const的作用是为了减少拷贝。

声明： istream& operator>>(istream& in, Date& d);
friend istream& operator>>(istream& in, Date& d);

定义

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

测试代码

void Test7()
{
	Date d1;
	cin >> d1;
	cout << d1;
}

为了更简洁，我们可以用内联函数。实际上在类里面定义的成员函数，就默认为内联函数。那么Date.cpp文件里可以不写，把定义放到.h文件里，前面加上inline

inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

inline istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

本篇最一开始给的链接可以看到全部的代码，里面出现的const可以暂且不管，下一篇会写出为什么加const。

结束。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/334627.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

WebDAV之葫芦儿·派盘+KMPlayer

WebDAV之葫芦儿·派盘+KMPlayer

KMPlayer 支持WebDAV方式连接葫芦儿派盘。 KMPlayer几乎可以播放您系统上所有的影音文件，支持几乎全部音视频格式。通过其强大的插件功能，可以支持层出不穷的新格式。软件还具有齐全的操控功能，支持捕获音频、捕获AVI、捕获画面、外挂字幕、自定义编辑设置，是视频爱好者的不…
阅读更多...
吞噬互联网：边缘计算和新商业网络的兴起

吞噬互联网：边缘计算和新商业网络的兴起

五年前&#xff0c;Gartner博客的一篇文章写道&#xff1a;“边缘将吞噬云。”表达的大概意思是&#xff0c;当大家都在特别关注云端时&#xff0c;Gartner看到了另一个方向——边缘&#xff0c;更能满足大家对低延迟和近乎实时处理的需求。如果快进五年&#xff0c;到2028 年&…
阅读更多...
【Spark分布式内存计算框架——Spark Core】4. RDD函数（下） 重分区函数、聚合函数

【Spark分布式内存计算框架——Spark Core】4. RDD函数（下） 重分区函数、聚合函数

重分区函数 如何对RDD中分区数目进行调整&#xff08;增加分区或减少分区&#xff09;&#xff0c;在RDD函数中主要有如下三个函数。 1&#xff09;、增加分区函数 函数名称&#xff1a;repartition&#xff0c;此函数使用的谨慎&#xff0c;会产生Shuffle。 2&#xff09;、…
阅读更多...
回归预测 | MATLAB实现PSO-LSSVM粒子群算法优化最小二乘支持向量机多输入单输出

回归预测 | MATLAB实现PSO-LSSVM粒子群算法优化最小二乘支持向量机多输入单输出

回归预测 | MATLAB实现PSO-LSSVM粒子群算法优化最小二乘支持向量机多输入单输出 目录回归预测 | MATLAB实现PSO-LSSVM粒子群算法优化最小二乘支持向量机多输入单输出预测效果基本介绍模型描述程序设计参考资料预测效果 基本介绍 MATLAB实现PSO_LSSVM粒子群算法优化最小二乘支持…
阅读更多...
车道线检测-LaneATT 论文学习笔记

车道线检测-LaneATT 论文学习笔记

论文&#xff1a;《Keep your Eyes on the Lane: Real-time Attention-guided Lane Detection》 地址&#xff1a;https://arxiv.org/abs/2010.12035v2 代码&#xff1a;https://github.com/lucastabelini/LaneATT 整体结构 车道线的表示方式 Lane{(xi,yi)}i0Npts−1,yii⋅Hima…
阅读更多...
【23种设计模式】结构型模式详细介绍

【23种设计模式】结构型模式详细介绍

前言 本文为 【23种设计模式】结构型模式 相关内容介绍&#xff0c;下边将对适配器模式&#xff0c;桥接模式&#xff0c;组合模式&#xff0c;装饰模式&#xff0c;外观模式&#xff0c;亨元模式&#xff0c;代理模式&#xff0c;具体包括它们的特点与实现等进行详尽介绍~ &a…
阅读更多...
mysql物理innobackupex备份脚本和自动备份脚本

mysql物理innobackupex备份脚本和自动备份脚本

目录 备份命令 恢复命令 自动备份脚本 innobackupex是一款MySQL备份工具&#xff0c;备份速度快(通过直接copy物理文件)&#xff0c;而且支持压缩、流式传输、加密等功能 新安装的数据库自带innobackupex&#xff0c;如果找不到命令&#xff0c;需安装percona-xtrabackup-2…
阅读更多...
python数据结构：数组、链表、栈、队列、树

python数据结构：数组、链表、栈、队列、树

目录1.数组1.1 数组的数据结构1.1.1 数组的定义1.1.2 随机访问和连续内存1.1.3 静态内存和动态内存1.1.4 物理大小和逻辑大小1.2 数组的操作1.2.1 增加数组大小1.2.2 减小数组大小1.2.3 插入一项1.2.4 删除一项1.2.5 复杂度权衡1.3 二维数组2.链表2.1 链表分类2.2 链表特点2.3 …
阅读更多...
OKCC呼叫中心使用中常见问题及处理方法

OKCC呼叫中心使用中常见问题及处理方法

经常有客户咨询在使用OKCC呼叫中心系统时遇到的一些常见但不复杂的问题&#xff0c;下面整理了一些问题和处理方法给伙伴们参考&#xff1a;一、外呼任务为何启动后会自动暂停&#xff1f;1.检查该账户余额是否充足&#xff1b;2.外呼任务班组中是否有空闲坐席&#xff1b;3.分…
阅读更多...
终于找到blender渲染总是崩溃的原因了

终于找到blender渲染总是崩溃的原因了

如果您开始渲染&#xff0c;Blender 会崩溃&#xff0c;并在渲染过程中自动关闭&#xff0c;可能是由于这两个主要原因之一。Blender 用完了可用内存显卡有问题在本文中&#xff0c;我们将了解如何处理 Blender 在渲染时崩溃的情况。Blender内存不足如果我们从 RAM 问题开始。要…
阅读更多...
卸载Node.js

卸载Node.js

0 写在前面 无论您是因为什么原因要卸载Node.js都必须要卸载干净。 请阅读&#xff1a; 1 卸载步骤 1.1通过控制面板卸载node.js winR—>control.exe—>卸载程序—>卸载Node.js 等待—>卸载成功 1.2 删除安装时的nodejs文件夹 通过记忆或者Everthing搜索找…
阅读更多...
《MySQL学习》 事务隔离 与 MVCC

《MySQL学习》 事务隔离 与 MVCC

《MySQL学习》 事务隔离 一.事务的概念 事务保证一组数据要么全部成功要么全部失败&#xff0c;MySQL的事务基于引擎&#xff08;如InnoDB&#xff09;实现。 二.事务的隔离性与隔离级别 MySQL的标准隔离级别&#xff1a; 读未提交 &#xff1a; 一个事务还没提交时&#…
阅读更多...
网络变压器与不同芯片之间的匹配原则及POE通讯产品需要注意哪些方面

网络变压器与不同芯片之间的匹配原则及POE通讯产品需要注意哪些方面

Hqst盈盛电子导读&#xff1a;网络变压器与不同芯片之间的匹配原则及POE通讯产品需要注意哪些方面网络变压器与不同芯片之间的匹配原则&#xff1a;一&#xff0c;电流型PHY芯片一般要配的网络变压器&#xff1a;1、变压器PHY侧3线共模电感 &#xff08;更适合POE产品&#xff…
阅读更多...
Nginx_3

Nginx_3

Rewrite功能配置 Rewrite是Nginx服务器提供的一个重要基本功能&#xff0c;是Web服务器产品中几乎必备的功能。主要的作用是用来实现URL的重写。www.jd.com 注意:Nginx服务器的Rewrite功能的实现依赖于PCRE的支持&#xff0c;因此在编译安装Nginx服务器之前&#xff0c;需要安…
阅读更多...
Thinkphp大型进销存ERP源码/ 进销存APP源码/小程序ERP系统/含VUE源码支持二次开发

Thinkphp大型进销存ERP源码/ 进销存APP源码/小程序ERP系统/含VUE源码支持二次开发

框架&#xff1a;ThinkPHP5.0.24 uniapp 包含:服务端php全套开源源码&#xff0c;uniapp前端全套开源源码&#xff08;可发布H5/android/iod/微信小程序/抖音小程序/支付宝/百度小程序&#xff09; 注&#xff1a;这个是全开源&#xff0c;随便你怎么开&#xff0c;怎么来&a…
阅读更多...
DHCP基础

DHCP基础

DHCP基础产生背景传统手工配置的缺陷DHCP基本概念及优点DHCP工作原理DHCP租期更新DHCP相关配置命令解析产生背景 因为现在上网的人已经变得非常多了&#xff0c;上网又需要分配IP地址&#xff0c;那么如何进行IP地址的分配&#xff1f;如果是手动分配IP地址&#xff0c;在人数…
阅读更多...
深眸科技以科技赋能智慧物流搭建，实现周转箱拆垛作业智能化

深眸科技以科技赋能智慧物流搭建，实现周转箱拆垛作业智能化

数字化时代下市场竞争的核心要素转化为科技的竞争&#xff0c;智能化技术的投入是企业占据市场竞争绝对优势的重要支撑。深眸科技凭借轻辙视觉引擎实现周转箱拆垛作业的智能化突破。人力成本增加&#xff0c;企业积极转变特别是在后疫情时代&#xff0c;人力成本迅猛增加&#…
阅读更多...
Docker进阶 - 7. docker network 网络模式之 host

Docker进阶 - 7. docker network 网络模式之 host

目录 1. host 模式概述 2. host模式代码语法 3. docker inspect 查看 bridge/host模式 容器元数据 4. ip addr 进入 tomcat83 (host模式) 容器内部查看容器ip 5. 如何访问启动 tomcat83 (host模式) 1. host 模式概述 直接使用宿主机的IP地址与外界进行通信&#xff0c;不…
阅读更多...
警惕！爆火的ChatGPT 暗藏的安全隐患 数字信息的未来

警惕！爆火的ChatGPT 暗藏的安全隐患 数字信息的未来

近段时间以来&#xff0c;ChatGPT 在各大平台网站是刷屏一般的存在&#xff0c;随之而来的各式各样的赞美与吁叹&#xff0c;更是不断地勾起人们的好奇心理。但在几天铺天盖地式的营销之后&#xff0c;ChatGPT 的舆论在2月7日晚的舆论风口就发现了极大的转变&#xff0c;各平台…
阅读更多...
2010-2019年290个城市经济发展与环境污染数据

2010-2019年290个城市经济发展与环境污染数据

2010-2019年290个城市经济发展与环境污染数据 1、时间&#xff1a;2010-2019年 2、统计口径&#xff1a;全市 3、来源&#xff1a;城市统计NJ&#xff0c;缺失情况与年鉴一致 4、指标包括&#xff1a; 综合经济&#xff1a;地区生产总值、人均地区生产总值、地区生产总值增…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023