Nullptr
#include<iostream>
void go(int num)
{
std::cout << "gonum" << std::endl;
}
void go(void *p)
{
std::cout << "gop" << std::endl;
}
void main()
{
//void *p = nullptr;
void *p = NULL;//C++是强类型，严格的类型检查
//go(p);//根据类型来处理，go(p) gop
go(NULL);//造成歧义，C++用Nullptr,gonum
go(nullptr);//C++的空指针，类型
std::cin.get();
}
const对象
#include<iostream>
class area
{
public:
int x;
int y;
mutable int z;//不受const约束的类成员
area() :x(10), y(10)
{
}
void printxy() const
{
z = z + 1;
std::cout << x << " " << y << "\n";
}
void add(int a)
{
x += a;
y -= a;
}
void go() const
{
}
protected:
private:
};
void main()
{
{
//const area *p1;
//area const *p2;
//const area * const p3;
//area *const p4;
}
//const对象不可以引用非const成员函数
//不可以改变内部变量,mutable例外
const area * const p = new area;
p->go();
//p->add();
//p = new area;//指针可以改变
const area area1;
area1.printxy();
//area1.add(1);
area1.go();
//area1.x = 10;
area1.z += 1;
std::cin.get();
}
类指针引用以及mallocfree与newdelete差别
#include<iostream>
#include <stdlib.h>
class myclass
{
public:
int x;
int y;
public:
myclass(int a, int b) :x(a), y(b)
{
std::cout << "构造哦" << std::endl;
}
myclass()
{
}
~myclass()
{
std::cout << "销毁哦" << std::endl;//
}
public:
void printxy();
protected:
private:
};
void myclass::printxy()
{
std::cout << x << " " << y << std::endl;
}
myclass class1(10, 11);//全局变量优先main函数
myclass class2(11, 12);
void change1(myclass **pp)
{
*pp = &class2;
}
void change2(myclass * &p)
{
p = &class1;
}
void main22()
{
myclass *p=&class1;
p->printxy();
change1(&p);
p->printxy();
change2(p);
p->printxy();
std::cin.get();
}
void main11()
{
//myclass *p = new myclass;
myclass *p(new myclass(10,9));//构造函数初始化
p->printxy();
myclass class1(20,1);
myclass ** pp = &p;//二级指针存储一级指针的地址
(*pp)->printxy();//一级类指针
(**pp).printxy();//0级类指针
std::cin.get();
}
void main122()
{
//myclass *p = (myclass *)malloc(sizeof(myclass));
//free(p);
myclass *p = new myclass;
delete p;
std::cin.get();
}
#include <iostream>
#include<stdlib.h>
class myclassA
{
public:
myclassA()
{
std::cout << "create\n";
}
~myclassA()
{
std::cout << "delete\n";
}
protected:
private:
};
void main()
{
//new delete自动调用构造析构
myclassA *p = new myclassA;
delete p;
//只会分配内存，释放内存，不会对内存进行操作
myclassA *p1 = (myclassA *)malloc(sizeof(myclassA));
free(p1);
std::cin.get();
}
类重载运算符
#include <iostream>
using namespace std;
class mycomplex
{
public:
//友元，需要操作类的内部
//ostream 引用标准输入输出流，
friend ostream & operator <<(ostream & out, mycomplex & Complex);
friend istream & operator >>(istream & in, mycomplex & Complex);
friend mycomplex operator +(mycomplex adddata1, mycomplex adddata2);
friend mycomplex operator +(mycomplex adddata1, int x);
//友元函数可以处理不同的类型交错
//成员函数能实现，友元函数都可以实现
//友元函数
int x;
int y;//x，y坐标
//没有构造无法使用this,初始化
mycomplex()
{
this->x = 0;
this->y = 0;
}
mycomplex(int x, int y) :x(x),y(y)
{
//this->x += 1;
//this->y += 1;
}
~mycomplex()
{
}
void show()
{
std::cout << x << "+" << y << "i" << std::endl;
}
void operator ++()
{
this->x++;
this->y++;
}
void operator --();
int operator ()(int num)//重载函数调用运算符，变量名可以当作一个函数调用参数，返回结果
{
cout << num << endl;
return num + num;
}
/*
mycomplex operator +(mycomplex adddata)
{
mycomplex temp;
temp.x = this->x + adddata.x;
temp.y = this->y + adddata.y;
return temp;
}
*/
protected:
private:
};
void mycomplex::operator--()
{
this->x--;
this->y--;
}
//输入输出，cout,屏幕，fout文件
ostream & operator <<(ostream & out, mycomplex & Complex)
{
out << Complex.x << "+" << Complex.y << "i" << std::endl;
return out;
}
istream & operator >>(istream & in, mycomplex & Complex)
{
cout << "请输入X,Y" << endl;
in >> Complex.x >> Complex.y;
return in;
}
mycomplex operator +(mycomplex adddata1 ,mycomplex adddata2)
{
mycomplex temp;
temp.x = adddata1.x + adddata2.x;
temp.y = adddata1.y + adddata2.y;
return temp;
}
mycomplex operator +(mycomplex adddata1, int x)
{
mycomplex temp;
temp.x = adddata1.x + x;
temp.y = adddata1.y + x;
return temp;
}
//++,--先自增，先自减
//
void main()
{
mycomplex my1(7, 8), my2(9, 10);
std::cout << my1 + my2 << std::endl;
std::cout << my1 + 3 << std::endl;
std::cin.get();
}
void main2()
{
mycomplex my1;
cin >> my1;
cout << my1;
//my1++;
++my1;
cout << my1;
my1--;
cout << my1;
std::cout<<my1(1)<<std::endl;
std::cout << my1(2) << std::endl;
std::cin.get();
std::cin.get();
}
void main1111()
{
mycomplex my1(7, 8),my2(9,10);
//my1.show();
//my2.show();
std::cout << my1;
std::cout << my2;
int num;
std::cin >> num;
//std::cin >> my1;
std::cin.get();
}
类的重载赋值运算复合赋值运算关系运算元重载
#ifndef DIALOG_H
#define DIALOG_H
#include <QDialog>
#include<QLabel>
namespace Ui {
class Dialog;
}
class mylabel
{
public:
QLabel *ql;
int cx;
int cy;
mylabel()
{
ql=new QLabel("12345") ;
cx=cy=300;
ql->move(cx,cy);//移动位置
}
~mylabel()
{
delete ql;
}
void show()
{
ql->show();
}
};
class Dialog : public QDialog
{
Q_OBJECT
public:
int x;//长 ，宽
int y;
int cx;//位置，x,y
int cy;
public:
explicit Dialog(QWidget *parent = 0);
friend void operator +=(Dialog & d , mylabel &my );
~Dialog();
void operator ++()
{
this->cx++;
this->cy++;
this->move(cx,cy);
}
void setxy()
{
this->resize(x,y);
}
void settoxy(int a,int b)
{
this->x=a;
this->y=b;
}
//二元运算符
Dialog * operator +(Dialog const &adddata)
{
Dialog *p=new Dialog;
p->x=this->x+adddata.x;
p->y=this->y+adddata.y;
return p;
}
Dialog *operator =(Dialog const &setdata)
{
this->x=setdata.x;
this->y=setdata.y;
this->setxy();
return this;
}
//int a,int b, a+=b
//Dialog a,int b,a+=b
Dialog *operator +=(int length)
{
this->x+=length;
this->y+=length;
this->setxy();
return this;
}
bool operator <(Dialog const &data)
{
return (this->x*this->y) < (data.x*data.y);
}
private:
Ui::Dialog *ui;
};
#endif // DIALOG_H
#include "dialog.h"
#include "ui_dialog.h"
Dialog::Dialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::Dialog)
{
ui->setupUi(this);
x=y=300;
this->resize(x,y);
cx=cy=0;
this->move(cx,cy);
}
Dialog::~Dialog()
{
delete ui;
}
void operator +=(Dialog & d , mylabel &my )
{
d.cx+=my.cx;
d.cy+=my.cy;
d.move(d.cx,d.cy);
}
#include "dialog.h"
#include <QApplication>
#include<Windows.h>
#include<QDebug>
void add(Dialog &add1,Dialog &add2)
{
Dialog temp;//栈上，用完了马上回收
temp.x=add1.x+add2.x;
temp.y=add1.x+add2.y ;
temp.show();
temp.setxy();
Sleep(2000);
//return 副本机制 return temp;
}
Dialog * addX(Dialog &add1,Dialog &add2)
{
Dialog *p=new Dialog;//堆上，只有自己回收才行
p->x=add1.x+add2.x;
p->y=add1.x+add2.y ;
p->show();
p->setxy();
return p;
}
// >
// =
//+=
//友元重载+=，= 不同类的对象的位置
template<class T>
void showall(T* myt)
{
myt->show();
}
//友元函数访问私有变量
//如果重载的时候，不用到私有变量，不需要友元
int main(int argc, char *argv[])
{
QApplication a(argc, argv);//框架支持
// QLabel *ql=new QLabel("12345");
// ql->show();
// showall(ql);
mylabel label1;
showall(&label1);
Dialog w1;
//w1.show();
showall(&w1);
w1+=label1;
return a.exec();
}
int mainC(int argc, char *argv[])
{
QApplication a(argc, argv);
Dialog w1;
w1.show();
w1.settoxy(400,700);
w1.setxy();
Dialog w2;
w2.show();
w2.settoxy(700,400);
w2.setxy();
w1=w2;
w1+=230;
qDebug()<<(w1<w2);
qDebug()<<(w2<w1);
return a.exec();
}
int mainB(int argc, char *argv[])
{
QApplication a(argc, argv);
Dialog w1;
w1.show();
Dialog w2;
w2.show();
// addX(w1,w2);
Dialog *p=w1+w2;
p->setxy();
p->show();
return a.exec();
}
int mainA(int argc, char *argv[])
{
QApplication a(argc, argv);
Dialog w;
w.show();
w.move(0,0);
for(int i=0;i<800;i++)
{
w++;
}
return a.exec();
}
自增在前在后差别
#ifndef DIALOG_H
#define DIALOG_H
#include <QDialog>
#include<QString>
namespace Ui {
class Dialog;
}
class Dialog : public QDialog
{
Q_OBJECT
public:
explicit Dialog(QWidget *parent = 0);
~Dialog();
void setxy(int a,int b)
{
this->x=a;
this->y=b;
}
Dialog *operator ++()
{
this->x += 1;
this->y += 1;
return this;
}
Dialog *operator ++(int data)
{
Dialog *ptemp=new Dialog;
ptemp->x=this->x;
ptemp->y=this->y;
this->x+=1;
this->y+=1;
return ptemp;
}
private slots:
void on_pushButton_clicked();
void on_pushButton_2_clicked();
void on_pushButton_3_clicked();
private:
Ui::Dialog *ui;
int x;
int y;
};
#endif // DIALOG_H
#include "dialog.h"
#include "ui_dialog.h"
Dialog::Dialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::Dialog)
{
ui->setupUi(this);
this->x=10;
this->y=100;
QString str1,str2;
str1.setNum(this->x);
str2.setNum(this->y);
ui->lineEdit->setText(str1);
ui->lineEdit_2->setText(str2);
}
Dialog::~Dialog()
{
delete ui;
}
void Dialog::on_pushButton_clicked()
{
QString str1,str2;
str1.setNum(this->x);
str2.setNum(this->y);
ui->lineEdit->setText(str1);
ui->lineEdit_2->setText(str2);
}
void Dialog::on_pushButton_2_clicked()
{
++(*this);
}
void Dialog::on_pushButton_3_clicked()
{
Dialog *p= (*this)++;
p->show();
}
#include "dialog.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
Dialog w;
w.show();
//w.setxy(10,20);
//++w;
// Dialog *p=w++;
// p->show();
return a.exec();
}
赋值重载深浅拷贝
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H
#include "mainwindow.h"
#include "ui_mainwindow.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
this->resize(100,100);
}
MainWindow::~MainWindow()
{
delete ui;
}
#include "mainwindow.h"
#include <QApplication>
#include<QDebug>
class morewindows
{
public:
MainWindow *p[5];//指针数组，每一个元素是指针
morewindows()
{
for(int i=0;i<5;i++)
{
p[i]=new MainWindow;
p[i]->show();
p[i]->move(i*100,i*100);
}
}
~morewindows()
{
for(int i=0;i<5;i++)
{
delete p[i];
}
}
};
class morewindowss
{
public:
MainWindow *p[5][4];
morewindowss()
{
for(int i=0;i<5;i++ )
{
for(int j=0;j<4;j++)
{
p[i][j]=new MainWindow;
p[i][j]->show();
p[i][j]->move(i*130,j*130);
}
}
}
~morewindowss()
{
for(int i=0;i<5;i++ )
{
for(int j=0;j<4;j++)
{
delete p[i][j];
}
}
}
};
//int a[5] int *p=a; int *p= new int[5];
//int *a[5] int **p=a int **p=new (int *)[5];
//int *a[3][5]
//int * (*p)[5]
class morewindowsss
{
public:
MainWindow **p;//二级指针
morewindowsss()
{
// p= (MainWindow **)malloc(sizeof(MainWindow *)*5);
}
void init(int num)
{
p= new MainWindow * [5];//new的时候类型不需要加上括号
for(int i=0;i<5;i++)
{
p[i]=new MainWindow;
p[i]->show();
p[i]->move(num*100,i*100);
}
}
void move(int x,int y)
{
for(int i=0;i<5;i++)
{
p[i]->move(x*100,y*100);
}
}
morewindowsss & operator = (morewindowsss const & more)//自己写的深拷贝
{
qDebug()<<"shen";
this->p = new MainWindow * [5];
for(int i=0;i<5;i++)
{
p[i]=new MainWindow;
p[i]->show();
p[i]->move(500,i*100);
}
return *this;
}
~morewindowsss()
{
for(int i=0;i<5;i++)
{
delete p[i];
}
delete [] p;
// free(p);
}
};
class morewindowssss
{
public:
// MainWindow *p[5][4];//二维数组，每一个元素都是指针
MainWindow **pA;//二级指针
MainWindow *(*p)[4];//指向二维指针数组的指针
morewindowssss()
{
pA=new MainWindow *[20];//一维数组
p=(MainWindow *(*)[4]) pA;
for(int i=0;i<5;i++ )
{
for(int j=0;j<4;j++)
{
p[i][j]=new MainWindow;
p[i][j]->show();
p[i][j]->move(i*130,j*130);
}
}
}
~morewindowssss()
{
for(int i=0;i<5;i++ )
{
for(int j=0;j<4;j++)
{
delete p[i][j];
}
}
delete [] pA;
}
};
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
morewindowsss more1;
more1.init(1);
// more1.move(1,2);
morewindowsss more2;//拷贝构造
more2=more1;//赋值
// morewindowsss more2(more1);
more2.move(3,4);
return a.exec();
}
重载下标
#include "mainwindow.h"
#include <QApplication>
class morewindow
{
public:
MainWindow *p[5];
morewindow()
{
for(int i=0;i<5;i++)
{
p[i]=new MainWindow;
p[i]->show();
p[i]->move(i*100,i*100);
}
}
~morewindow()
{
for(int i=0;i<5;i++)
{
delete p[i];
}
}
MainWindow * operator [](int i)
{
return p[i];
}
};
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
morewindow more1;
more1[3]->hide();//重载下标
return a.exec();
}
