前言

界面包含多个按钮，每个按钮实现相同的功能，但是操作的对象不同，例如点击按钮清除对应输入框内容，可以用多个按钮关联同一个槽函数，然后通过槽函数来控制不同按钮操作不同输入框，查到有两种方法可以使用，分别编写了两个方法的代码如下。

方法一 ：ObjectName

通过setObjectName（）在定义button处先设置ObjectName，后在槽函数中判断信号的名称。可实现清除对应输入框功能。

mybutton.h

#ifndef MYBUTTON_H
#define MYBUTTON_H

#include <QWidget>
#include <QPushButton>
#include <QLineEdit>

namespace Ui {
class MyButton;
}

class MyButton : public QWidget
{
    Q_OBJECT

public:
    explicit MyButton(QWidget *parent = 0);
    ~MyButton();

private:
    Ui::MyButton *ui;
    QPushButton *clearBtn[6];
    QLineEdit *edit[6];
private slots:
    void buttonClicked();
};

#endif // MYBUTTON_H

mybutton.cpp

#include "mybutton.h"
#include "ui_mybutton.h"
#include <QPushButton>
#include <QVBoxLayout>
#include <QDebug>
#include <QLineEdit>

MyButton::MyButton(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MyButton)
{
    ui->setupUi(this);
    QVBoxLayout* buttonLayout = new QVBoxLayout(this);
    for(int i=0;i<6;i++)
    {
        edit[i] = new QLineEdit();
        clearBtn[i] = new QPushButton("clear"+QString::number(i));
        clearBtn[i]->setObjectName("button"+QString::number(i)); //设置名称
        buttonLayout->addWidget(edit[i]);
        buttonLayout->addWidget(clearBtn[i]);
        connect(clearBtn[i],SIGNAL(clicked(bool)),this,SLOT(buttonClicked()));
    }
}
MyButton::~MyButton()
{
    delete ui;
}
void MyButton::buttonClicked()
{
    QString btnName = QObject::sender()->objectName();
    int index = (btnName.mid(6,-1)).toInt();
    switch(index)
    {
    case 0:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 1:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 2:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 3:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 4:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 5:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    default:
        qDebug()<<"button";
        break;
    }
}

方法二 ：QSignalMapper

通过QSignalMapper类中setMapping()将特定的字符串或整型数对应到特定的对象上，该特定对象的signal可以被连接到QSignalMapper的map() slot，而map()会发射带参数mapped() signal，参数就是signal的特定对象的标识信息，下面的代码以整型为例，作为参数。

mybutton.h：

#ifndef MYBUTTON_1_H
#define MYBUTTON_1_H

#include <QWidget>
#include <QPushButton>
#include <QLineEdit>
namespace Ui {
class myButton_1;
}

class myButton_1 : public QWidget
{
    Q_OBJECT

public:
    explicit myButton_1(QWidget *parent = 0);
    ~myButton_1();

private:
    Ui::myButton_1 *ui;
    QPushButton *clearBtn[6];
    QLineEdit *edit[6];
private slots:
    void buttonClicked(int index);
};

#endif // MYBUTTON_1_H

mybutton.cpp：

#include "mybutton_1.h"
#include "ui_mybutton_1.h"

#include <QSignalMapper>
#include <QPushButton>
#include <QVBoxLayout>
#include <QDebug>
#include <QLineEdit>

myButton_1::myButton_1(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::myButton_1)
{
    ui->setupUi(this);
    QVBoxLayout* buttonLayout = new QVBoxLayout(this);
    QSignalMapper* mapper = new QSignalMapper(this);
    for(int i=0;i<6;i++)
    {
        edit[i] = new QLineEdit();
        clearBtn[i] = new QPushButton("clear"+QString::number(i));
        buttonLayout->addWidget(edit[i]);
        buttonLayout->addWidget(clearBtn[i]);
        mapper->setMapping(clearBtn[i],i);
        connect(clearBtn[i],SIGNAL(clicked()),mapper,SLOT(map()));
    }

    connect(mapper,SIGNAL(mapped(int)),this,SLOT(buttonClicked(int)));

}

myButton_1::~myButton_1()
{
    delete ui;
}

void myButton_1::buttonClicked(int index)
{
    switch(index)
    {
    case 0:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 1:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 2:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 3:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 4:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    case 5:
        qDebug()<<"button:"<<index;
        edit[index]->clear();
        break;
    default:
        qDebug()<<"button";
        break;
    }
}

运行

构造函数主要包括：默认构造函数、普通构造函数、拷贝构造函数三种。
构造函数经常与赋值函数混淆，这里放在一起讲，便于区分。

首先初始化一个简单的类作为例子讲解：

class A {
public:   
    A() {
        v = 1;
        printf("默认构造(无参数)\n");
    }
    
    A(int t = 1) {
        v = 1;
        printf("默认构造(有参数，且参数有默认值)\n");
    }
    
    A(int t) {
        v = t;
        printf("普通构造1\n");
    }

    A(int t,int f) {
        v = t;
        m = f;
        printf("普通构造2\n");
    }
    //默认构造函数只能有一个，当有参默认构造函数的参数列表与普通构造函数的参数列表一样时，两者也只能存在一个。

    A(const A& a) {
        this->v = a.v;
        printf("拷贝构造\n");
    }

    A& operator= ( A& a) {
        this->v = a.v;
        printf("赋值函数\n");
        return *this;
    }

    ~A() {
        printf("析构函数\n");
    }

    int v;
    int m;
};

1、 默认构造函数

①准确的说，默认构造函数就是在调用时不需要显示地传入实参的构造函数。
②一个类只能有一个默认构造函数。

1.1、默认构造函数

当类中没有定义任何构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空。
此外，用户可自定义默认构造函数如下。

实现形式：

    A() {
        //可以为空，为空则与编译器生成的默认构造函数相同
    }

    A(int t = 1) {
        v = t;
    }

上述两种默认构造函数不能同时存在，否则在调用默认构造函数时会引起二义性。

调用形式：

int main() {
    A a;//默认构造函数
    return 0;
}

*C++构造函数重载以及默认参数引起的二义性

问题解析

当我们同时定义一个带默认参数的默认构造函数和一个不带参数的默认构造函数之后（一般不这样做，两种构造函数不应被同时定义），在定义一个类对象时，如果不传递参数，会出现二义性错误。因为我们没有传递参数时，系统默认又两种选择，一种是调用无参的默认构造函数，另一种是调用带参默认构造函数并传递默认参数。

  class A  
  {  
  public:  
     A()  
     {  
         v = 0;  
     }  
       
     A(int r = 0)  
     {  
         v = r;   
     }  
     int v;
 };  
 int main()  
 {  
         A c;//error: call of overloaded ‘Complex()’ is ambiguous  
         return 0;  
 } 

会报错：error: call of overloaded ‘Complex()’ is ambiguous

解决方法

1.去掉无参默认构造函数。

  class A  
  {  
  public:  
     A(int r = 0)  
     {  
         v = r;   
     }  
     int v;
 }; 

这时，当我们不给构造函数传递参数时，系统会调用有参默认构造函数并传递默认参数对类数据成员进行初始化。

int main() {
    A a;
    //相当于
    A a(0);//有参默认构造函数
    return 0;
}

2.去掉带参默认构造函数的默认参数

  class A  
  {  
  public:  
     A()  
     {  
         v = 0;  
     }  
       
     A(int r)  //去掉带参构造函数的默认参数
     {  
         v = r;   
     }  
     int v;
 };  

此时带参默认构造函数就变成了普通构造函数。

1.2、默认拷贝构造函数

当类中没有定义任何拷贝构造函数时，编译器默认提供一个默认拷贝构造函数，简单的进行成员变量的值的赋值。这里涉及到深拷贝和浅拷贝的知识，将在拷贝构造函数小节详述。

2、 普通构造函数

实现形式：

    //通过参数列表的不同进行重载
    A(int t) {
        v = t;
    }
    
    A(int t,int f) {
        v = t;
        m = f;
    }
    
    A(int t): v(a) {}//普通构造函数1的参数列表形式
    A(int t,int f): v(a), m(f) {}//普通构造函数2的参数列表形式

调用形式：

int main() {
    A a(1);//普通构造函数1
    A a(1,1);//普通构造函数2
    return 0;
}

3、 拷贝构造函数（复制构造函数）

实现形式：

    A(const A& a) {
        this->v = a.v;
        printf("拷贝构造\n");
    }

调用形式（三种情况）：

3.1、对象需要通过另一个对象进行初始化

int main() {
    A a(1);
    A b = a;//拷贝构造函数形式一
    A c(a);//拷贝构造函数形式二,最好写成这种形式
    return 0;
}

3.2、对象通过值传递方式进入函数

void g(A ret) {
    printf("函数作为参数\n");
}
int main() {
    A a(1);
    g(a);//作为参数传入函数时调用拷贝构造函数
    return 0;
}

3.3、对象以值传递方式从函数返回

A f() {
    A ret(3);
    return ret;
}
int main() {
    A a(1);
    A b = f();//以值传递方式从函数返回时调用拷贝构造函数
    return 0;
}

*关于深拷贝与浅拷贝

浅拷贝，即在定义一个类A，使用类似A obj; A obj1(obj);或者A obj1 = obj; 时候，由于没有自定义拷贝构造函数，C++编译器自动会产生一个默认的拷贝构造函数。这个默认的拷贝构造函数采用的是“位拷贝”（浅拷贝），而非“值拷贝”（深拷贝）的方式，如果类中含有指针变量，默认的拷贝构造函数必定出错。

浅拷贝

浅拷贝：也就是在对象复制时，只是对对象中的数据成员进行简单的赋值，如果对象中存在动态成员，即指针，浅拷贝就会出现问题，下面代码：

class A
{
public:
    A()      // 构造函数，p指向堆中分配的一空间
    {
        m_data = new char(100);
        printf("默认构造函数\n");
    }
    ~A()     // 析构函数，释放动态分配的空间
    {
        if (m_data != NULL)
        {
            delete m_data;
            m_data = NULL;
            printf("析构函数\n");
        }
    }
private:
    char* m_data;     // 一指针成员
};

int main()
{
    A a;
    A b(a);   // 拷贝构造
    return 0;
}

分析：由于没有拷贝构造函数，走编译器默认的拷贝构造函数，A b(a); 进行对象析构时，会造成释放同一内存空间2次。

深拷贝

对于深拷贝，针对成员变量存在指针的情况，不仅仅是简单的指针赋值，而是重新分配内存空间，如下：

class A
{
public:
    A()      // 构造函数，p指向堆中分配的一空间
    {
        m_pdata = new char(100);
        printf("默认构造函数\n");
    }

    A(const A& r)
    {
        m_pdata = new char(100);    // 为新对象重新动态分配空间
        memcpy(m_pdata, r.m_pdata, strlen(r.m_pdata));
        printf("深拷贝构造函数\n");
    }

    ~A()     // 析构函数，释放动态分配的空间
    {
        if (m_pdata != NULL)
        {
            delete m_pdata;
            printf("析构函数\n");
        }
    }

private:
    char* m_pdata;     // 一指针成员
};

int main()
{
    A a;
    A b(a);   // 拷贝构造
    return 0;
}

4、 赋值函数

赋值函数不属于构造函数，它是“=”运算符的重载函数。只有两个已经声明的对象之间（两个已经在内存中存在的对象）才能进行赋值。
实现形式：

    A& operator= ( A& a) {
        if (this != &a)
        {
            this->v = a.v;
        }
        printf("赋值函数\n");
        return *this;
    }

①返回类型为自身类的引用，使得赋值函数可以联等赋值。

A t2,t3;
t2=t3=t1;//假设t1是已被初始化的对象

②形参为类的引用，可以避免重复调用拷贝构造函数，const可以保护传入对象自身的安全。

调用形式：

int main() {
    A a(1);
    A b;
    b = a;//赋值函数
    return 0;
}

5、string类各种初始化时所调用的构造函数

//初始化方法1
string a;//调用无参默认构造函数，初始化后对象a内的字符串成员为空。
//初始化方法2
string a = "abc";//先调用普通构造函数生成一个匿名string对象，再调用拷贝构造函数把匿名对象拷贝给a。
//该语句等同于：
string a(string("abc"));
//初始化方法3 
string a("abc");//调用普通构造函数
//初始化方法4 
string a(b);//调用拷贝构造函数
//初始化方法5 
string a = b;//调用拷贝构造函数
//方法6 (a,b已初始化)
a = b;//调用赋值函数

一般来说类与类有六种关联方式：单向关联，双向关联，自关联，多重性关联，聚合关系，组合关系。

1.单向关联一般是把B类作为A类的一个属性来实用，例如Company是一个类，Employee是一个类。然而Company类将Employee作为其的一个属性。

2.双向关联，就是说将对方（类）当做自己的一个属性。例如顾客与商品的关系，顾客购买商品，卖出的商品与某个顾客关联。

3.自关联的比如链表中的节点，可以指向自己，把自己当做自己类的一个属性。

4.多重性关联，即A类把多个B类当做属性。

5.聚合关系，这是表示整体与部分之间的关系，成员对象是整体对象的一部分，但成员对象时可以脱离整体对象存在的

一个不恰当的例子是，一个三口家庭是由父亲，母亲，儿子存在组成整体部分的，但是父亲是可以可以脱离整体部分存在的。（不是很恰当的举例），两者关系较弱，通过对象注入实现。

6.组合关系，也是表示整体与部分之间的关系，但是部分不能脱离整体存在，整体没了它就没了。例如腾讯与QQ的关系，没了腾讯这家公司，QQ软件也没了。两者关系较强，通过构造函数实例化来实现。