varray: 灵活的数组结构与stl valarray的解构（2）

最新推荐文章于 2021-08-19 10:41:25 发布
最新推荐文章于 2021-08-19 10:41:25 发布
阅读量739 收藏
点赞数
分类专栏： 学习C++ 文章标签： class 工作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sguox002/article/details/6766865
版权
本文继续讨论自定义的varray类，重点在于实现各种运算符的重载，包括一元操作符（+，-，！，~），二元操作符（+，-，*，/，%等）以及与varray对象和标量的数学运算。此外，还介绍了与STL valarray类似的数学函数，如sin, cos, tan等，并定义了barray和ind_array来表示特定类型的数组。通过这些操作符重载，varray类变得更加灵活，能够进行丰富的数组运算。" 123584114,11701874,MySQL数据库原理与实践解析,"['mysql', '数据库管理', 'SQL查询', '数据存储', '事务']
摘要由CSDN通过智能技术生成

上一片文章我们构造了一个简单的varray类，对这个用户定义的具体类型来说，还不够功能完善，有很多的运算符操作都没有放进去。这是特的为了表述清楚而没有加入的。

这类操作包括：

1。取+/-/~/！等操作

2。与标量的数学运算：+，-，*，/，%，|，&, 

3。与varray对象间的数学运算

4. bit运算

5。逻辑运算


首先需要考虑的问题便是：我们要把这些操作当作成员函数还是当作非成员函数。 我们注意到，有些运算符只能用作成员函数，比如赋值运算符。

成员函数优点：有一个操作数是隐含的，可以简化程序。缺点：在某些操作如果第一个操作数不是类对象时，就会出现无法使用的情况。这样就必须在外面加入若干的全局函数。如果这些函数要存取类的成员变量，还有必要将其设置为友元函数。

作为全局函数的优点是：类的接口比较简单。一般比较喜欢这种方式。

这里我实现了一部分运算符重载，类似的工作多为重复性的劳动，只要掌握了其中的原理即可。

valarray还实现了大部分的数学函数，如sin, cos, tan, ......


值得一提的是，我们有必要定义几种类型，包括 barray, ind_array, 用来表示真值数组和下标数组类型。（分别对应valarray中的mask_array和indirect_array)


template <class T> class varray;
typedef varray<bool> barray;
typedef varray<int> ind_array;

//operators
//unary: +, -, !(not), ~(bit complement)
varray<T> operator+() 
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=+data[i];return tmp;}
varray<T> operator-() 
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=-data[i];return tmp;}
varray<T> operator~() 
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=~data[i];return tmp;}
varray<T> operator!() 
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=!data[i];return tmp;}


varray<T>& operator+=(const T& x)
{for(int i=0;i<size();i++) data[i]+=x;return *this;}
varray<T>& operator-=(const T& x)
{for(int i=0;i<size();i++) data[i]-=x;return *this;}
varray<T>& operator*=(const T& x)
{for(int i=0;i<size();i++) data[i]*=x;return *this;}
varray<T>& operator/=(const T& x)
{for(int i=0;i<size();i++) data[i]/=x;return *this;}
varray<T>& operator%=(const T& x)
{for(int i=0;i<size();i++) data[i]%=x;return *this;}
varray<T>& operator^=(const T& x)
{for(int i=0;i<size();i++) data[i]^=x;return *this;}
varray<T>& operator&=(const T& x)
{for(int i=0;i<size();i++) data[i]&=x;return *this;}
varray<T>& operator|=(const T& x)
{for(int i=0;i<size();i++) data[i]|=x;return *this;}
varray<T>& operator>>=(const T& x)
{for(int i=0;i<size();i++) data[i]>>=x;return *this;}
varray<T>& operator<<=(const T& x)
{for(int i=0;i<size();i++) data[i]<<=x;return *this;}


varray<T>& operator+=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]+=v[i];return *this;}
varray<T>& operator-=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]-=v[i];return *this;}
varray<T>& operator*=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]*=v[i];return *this;}
varray<T>& operator/=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]/=v[i];return *this;}
varray<T>& operator%=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]%=v[i];return *this;}
varray<T>& operator^=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]^=v[i];return *this;}
varray<T>& operator&=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]&=v[i];return *this;}
varray<T>& operator|=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]|=v[i];return *this;}
varray<T>& operator>>=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]>>=v[i];return *this;}
varray<T>& operator<<=(const varray<T>& v)
{for(int i=0;i<size();i++) data[i]<<=v[i];return *this;}


varray<T> operator+(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]+x;return tmp;}
varray<T> operator-(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]-x;return tmp;}
varray<T> operator*(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]*x;return tmp;}
varray<T> operator/(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]/x;return tmp;}
varray<T> operator%(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]%x;return tmp;}
varray<T> operator^(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]^x;return tmp;}
varray<T> operator&(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]&x;return tmp;}
varray<T> operator|(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]|x;return tmp;}
varray<T> operator<<(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]<<x;return tmp;}
varray<T> operator>>(const T& x)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]>>x;return tmp;}


varray<T> operator+(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]+v[i];return tmp;}
varray<T> operator-(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]-v[i];return tmp;}
varray<T> operator*(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]*v[i];return tmp;}
varray<T> operator/(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]/v[i];return tmp;}
varray<T> operator%(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]%v[i];return tmp;}
varray<T> operator^(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]^v[i];return tmp;}
varray<T> operator&(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]&v[i];return tmp;}
varray<T> operator|(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]|v[i];return tmp;}
varray<T> operator<<(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]<<v[i];return tmp;}
varray<T> operator>>(const varray<T>& v)
{varray<T> tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]>>v[i];return tmp;}


barray operator&&(const T& x)
{barray tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]&&x;return tmp;}
barray operator||(const T& x)
{barray tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]||x;return tmp;}
barray operator&&(const varray<T>& v)
{barray tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]&&v[i];return tmp;}
barray operator||(const varray<T>& v)
{barray tmp(size());for(int i=0;i<size();i++) tmp[i]=data[i]||v[i];return tmp;}



//global functions
//some operators which has a scalar as the first


//some functions
template <class T> varray<T> sin(const varray<T>& v)
{varray<T> tmp(v.size());for(int i=0;i<v.size();i++) tmp[i]=::sin(v[i]);return tmp;}
template <class T> varray<T> cos(const varray<T>& v)
{varray<T> tmp(v.size());for(int i=0;i<v.size();i++) tmp[i]=::cos(v[i]);return tmp;}
template <class T> varray<T> tan(const varray<T>& v)
{varray<T> tmp(v.size());for(int i=0;i<v.size();i++) tmp[i]=::tan(v[i]);return tmp;}
template <class T> varray<T> sinh(const varray<T>& v)
{varray<T> tmp(v.size());for(int i=0;i<v.size();i++) tmp[i]=::sinh(v[i]);return tmp;}
template <class T> varray<T> cosh(const varray<T>& v)
{varray<T> tmp(v.size());for(int i=0;i<v.size();i++) tmp[i]=::cosh(v[i]);return tmp;}
template <class T> varray<T> exp(const varray<T>& v)
{varray<T> tmp(v.size());for(int i=0;i<v.size();i++) tmp[i]=::exp(v[i]);return tmp;}



益阳浪子
关注
专栏目录
PL/SQL数组(varray)操作实例说明
WEL测试
03-28 5200
本文使用系统自带的表emp表，对应的表结构和数据截图如下：创建测试脚本窗口输入如下脚本信息：-- Created on 2018/3/28 by E.WANG /* VARRAY数据结构可存储相同类型元素的一个固定大小的连续集合。 VARRAY用于存储数据的有序集合，但它往往是更加有用认为数组作为相同类型的变量的集合。 所有可变数组由连续的存储位置。最低的地址对应于第一元素和最高地址的最后一个元...
第4关：Numpy数组的堆叠
SorrymakerS的博客
04-25 2883
任务描述 本关的目标是，改变Numpy数组的形状。 相关知识 使用Numpy，我们可以方便的更改数组的形状，比如使用reshape()、ravel()、flatten()、transpose()函数等。 具体的使用如下： 改变数组形状 reshape() import numpy as np In: b = np.arange(24).reshape(2,3,4) In: b Out: array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]
VARRAY
pskfire007的专栏
09-25 150
[code="java"]DECLARE TYPE varray_type IS VARRAY(10) OF NUMBER; varray varray_type := varray_type(1, 2, 3, 4, 5, 6); TYPE varray_string is VARRAY(10) OF VARCHAR2(5); test_string varray_stri...
oracle—varray
weixin_30306905的博客
03-04 277
VARRAY(变长数组）通俗的讲就是一个存储有序的元素集合，而其每个元素都有一个相关索引，该索引相对应元素在数组中的位置。变长数组存在大小的限制，但是可以动态进行更改。 Create Type varray_phone as varray(3) of varchar2(50); 　　 1. 声明和初始化VARRAY变量 不可以直接声明一个VARRAY变量。必须先声明一个包含...
pl/sql集合类型_varray(二)
09-23 138
-------------------------------------------------------------------------------------变长数组 varray 它是一种用于处理PL/...
oracle可变数组（VARRAY）
wo2han123456的博客
08-19 2313
一、可变数组的定义： 　　可变数组与嵌套表相似，也是一种集合。一个可变数组是对象的一个集合，其中每个对象都具有相同的数据类型。可变数组的大小由创建时决定。在表中建立可变数组后，可变数组在主表中作为一个列对待。从概念上讲，可变数组是一个限制了行集合的嵌套表。 　　可变数组，允许用户在表中存储重复的属性。例如：假设用户有一个project表，并在项目中指定了工作人员，一个项目可以有多个工人，而一个工人也可以为多个项目工作。在严格的关系模型中，用户可以创建一个project表，一个worker表和存储它们之间
oracle中变长数组varray,嵌套表,集合使用方法
09-10
在Oracle数据库中，变长数组（VARRAY）和嵌套表是两种集合类型，它们用于存储一组相关的数据。本文将详细介绍这两种数据结构的创建、使用、修改和查询方法。 首先，我们来看变长数组（VARRAY）。变长数组是一种限制...
Oracle数据库中变长数组Varray与嵌套表操作详解
本文主要介绍了Oracle数据库中两种重要的集合类型：变长数组（VARRAY）和嵌套表（Nested Table），以及如何创建、修改和使用它们的方法。 在Oracle数据库中，变长数组（VARRAY）是一种限制了固定大小的集合类型，...
oracle 集合 varray
csdn1284934570的专栏
07-10 1240
1、创建语法       Create Or Replace varray_type_name Is Varray(size_limit) Of Element_type [Not Null];       varray_obj varray_type_name;       注：下标从1开始，元素个数有限制 使用变长数组对象元素前，必须使用构造函数初始化 2、实例 Create O
varray: 灵活的数组结构与stl valarray的解构（1）
09-11 544
valarray可以实现灵活的数组结构。我仿造valarray一步一步地实现这个类。由此我们可以看到 stl的类并不神秘。 第一步：我只实现了灵活数组类的基本功能，包括如何构造，赋值，以及简单的运算，和元素的存取。 这个数组类包含一个数据指针和数组长度。同时为了方便改变长度，
plsql 集合类型详解（varray、table）
鱼丸丶粗面
12-18 4050
文章目录1 概述2 集合2.1 varray 单行多列 限定长度2.2 关联数组 单行多列 index by2.3 嵌套表 多行多列3 常见问题3.1 delete 和 置 null 的区别3.2 ORA-01403：未找到任何数据3.3 数组属性和函数 1 概述 1. 集合：具有相同定义的元素的聚合，有以下三种 (1) varray: 指定最大长度 -- varray(3) of varchar2(30); (2) 关联数组: index by -- table of varchar2(30)
ODAC 使用技巧 （四）使用VARRAY数据类型
开心果的专栏
03-08 2232
 ODAC 使用技巧 （四）使用VARRAY数据类型nxyc_twz@163.com   在使用对象时建议使用数组。但在你需要在数据集中使用大数组时可能会出现一些问题。比如，当为 ODAC 的一个字段创建大量数组时，也会创建大量的 TField 字段，这会导致程序的性能大大降低。 因此， ODAC 限制仅能为字段创建 1000 个成员。 但不管怎样，你都可以使用 TOraArray 对
数组VARRAY使用
mandy_rxr的专栏
10-20 644
-- varray类型变量存储的是数字类型 DECLARE TYPE type_varray_date IS VARRAY(5) OF number(10); varray_date type_varray_date; BEGIN varray_date := type_varray_date( 1, 2, 3, 4, 5 ); FOR i IN 1 ....
数组RECORD、VARRAY、TABLE详解
mandy_rxr的专栏
10-20 630
1 RECORD、VARRAY、TABLE的详解 1.1 RECORD 定义记录数据类型。它类似于C语言中的结构数据类型(STRUCTURE)，PL/SQL提供了将几个相关的、分离的、基本数据类型的变量组成一个整体的方法，即RECORD复合数据类型。在使用记录数据类型变量时，需要在声明部分先定义记录的组成、记录的变量，然后在执行部分引用该记录变量本身或其中的成员。 ...
Oracle VARRAY的实际应用简介
secondsyy的博客
11-05 155
Oracle VARRAY(变长数组）通俗的讲就是一个存储有序的元素集合，而其每个元素都有一个相关索引，该索引相对应元素在数组中的位置。变长数组存在大小的限制，但是可以动态进行更改。 创建变长数组语句：   Create Type varray_phone as varray(3) of varchar2(50);  接下来应用这个变长数组，先创建一个人员表，人员表中拥有一列电话，类...
ORACLE 中 VARRAY的用法
从零开始
05-03 1万+
看到同事写的存储过程里面有这样一句：     TYPE ARRAY_TYPE IS VARRAY(10000) OF VARCHAR2(60);     感到很茫然，幸好还有网络可以求助，我理解成是：长度为10000的数组，其每个为长度为最大长度为60的varchar2类型。不知是否准确？ 1. 声明和初始化VARRAY变量 你不可以直接声明一个VARRAY变量。必须先声明
六、STL的数值计算---数组（向量）运算---mask_array类
jingza的博客
08-17 651
4.类mask_array valarray类提供了一种描述子集的方式： 屏蔽子集。 valarray类经过“屏蔽”处理后，返回结果为valarray<bool>型 将“屏蔽”作为下标，值为true的位表明了对应的valarray数组中的元素将作为结果的一部分。 和slice_array一样，mask_array不能有程序开发者构造和复制。 屏蔽的valarray的元素的个数不能多于valarray
oracle varray
oracle_my_love的专栏
08-03 331
关于ORACLE中的数组：记录同集合 集合可以有三种实现方式： 1 自定义一个TYPE使用VARRAY来得到一个数组但只能对基本类型定义如： CREATE TYPE 类型名 AS VARRAY OF VARCHAR2（20）； 1 自定义一个TYPE使用VARRAY来得到一个数组但只能对基本类型定义如： CREATE TYPE 类型名 AS VARRAY（52） OF VARCHAR2（20）；...
C++11中std::array的使用
热门推荐
网络资源是无限的
05-30 6万+
C++11中std::array的使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值