#include
using namespace std;
class Array
{
public:
Array(){length = 0; num = NULL;}
Array(int * A, int n);
Array(Array & a);
Array & operator= (const Array & a);
void setnum(int value, int index);
int * getaddress();
void display();
int getlength(){return length;}
private:
int length;
int * num;
};
Array::Array(Array & a)
{
if(a.num != NULL)
{
length = a.length;
num = new int[length];
for(int i=0; i
#include
#include
using namespace std;
class Array
{
public:
Array(){len1 = 0; len2 = 0; num = NULL; }
Array(int m, int n);
int & operator()(int, int);
const int & operator()(int, int)const;
int getlen1()const {return len1;}
int getlen2()const {return len2;}
private:
int len1;
int len2;
int * num;
};
Array::Array(int m, int n)
{
int size = m * n;
try
{
num = new int[size];
}
catch(bad_alloc)
{
cerr<<"allocate storage failure!"<= len1)
throw string("1 out of bounds!");
if(j < 0 || j >= len2)
throw string("2 out of bounds!");
return num[ i*len2 + j ];
}
const int & Array::operator()(int i, int j)const
{
if(i < 0 || i >= len1)
throw string("1 out of bounds!");
if(j < 0 || j >= len2)
throw string("2 out of bounds!");
return num[ i*len2 + j ];
}
int main()
{
Array A(3,4);
int i,j;
for(i = 0; i < A.getlen1(); i++){
for(j = 0; j < A.getlen2(); j++){
A(i,j) = i * A.getlen2() + j;
}
}
for(i = 0; i < A.getlen1(); i++){
for(j = 0; j < A.getlen2(); j++){
cout<< A(i,j)<<" ";
}
cout<
image.png
定义了一个Array类,这个类描述的是一个二维的数组,在类中我们先定义了一个默认构造函数,之后声明了一个带参数的构造函数“Array(int m, int n);”,所带的这两个参数分别是数组的两个维度的大小。 之后声明了一个函数调用操作符重载函数“int & operator()(int, int);”和“const int & operator()(int, int)const;”,同样的,因为只有常成员函数才能处理常对象,故依然在类中提供两个版本的函数调用操作符重载函数。 可以去看一下两个函数的函数定义,在它们的函数体中,我们先是做一个越界检测,当然对于二维数组而言,边界是有两个的,因此有两次边界检测的。如果没有越界则会返回对应的值。有了这两个函数调用操作符重载函数,我们就可以用A(i,j)的形式访问二维数组中的数据了。
定义了一个简单的秒表类,该类有两个私有成员变量min和sec,分别代表分钟和秒钟。在类中声明的成员函数setzero是用于秒表清零,run函数是用于描述秒针向前进一秒的动作,之后是三个操作符重载函数,前两个分别是重载自增操作符,最后一个是重载输出操作符。 先来看一下run函数的实现,run函数一开始让秒针自增,如果此时自增结果等于60了,则应该进位,分钟加1,秒针置零。 再来看一下operator++()函数的实现,该函数时实现自增的前置形式,因此直接返回run()函数运行结果即可。 对于operator++ ( int n )函数,这是实现自增的后置形式,自增的后置形式返回值是对象本身,但是之后再次使用该对象时,该对象自增了,因此在该函数的函数体中,先将对象保存,然后调用一次run函数,之后再将先前保存的对象返回,在这个函数中参数n是没有任何意义的,它的存在只是为了区分是前置还是后置形式。 最后我们还重载了输出操作符,以便于我们打印计时结果。
#include
using namespace std;
class clock
{
public:
clock(){hour = min = ap = 0;}
clock(int h, int m, int ap);
operator int();
private:
int hour;
int min;
int ap; // 0表示am, 1表示pm
};
clock::clock(int h, int m, int ap)
{
hour = h;
min = m;
this->ap = ap;
}
//转型操作符重载函数
clock::operator int()
{
int time = hour;
if(time == 12){
time = 0;
}
if(ap == 1){
time += 12;
}
time *= 100;
time += min;
return time;
}
int main()
{
clock c(5,7,1);
int time = c;
cout<
快速高效用:SET SQL_SAFE_UPDATES = 0;下面的就不要看了!
今日用MySQL Workbench进行数据库的管理更新时,执行一个更新的语句碰到以下错误提示:
Error Code: 1175
You are using safe update mode and you tried to update a table without a WHERE that
Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
Note:You may assume that nums1 has enough space (size that is