Опубликован: 10.12.2015 | Доступ: платный | Студентов: 23 / 7 | Длительность: 07:10:00
Лекция 13:

Перегрузка функций

< Лекция 12 || Лекция 13 || Лекция 14 >

Перегрузка функций используется для того, чтобы функции с одним и тем же именем выполнялись по-разному в зависимости от типа и количества фактических параметров.

Для обеспечения перегрузки функций необходимо для каждого имени определить, сколько разных функций связано с ним, т.е. сколько вариантов сигнатур допустимы при обращении к ним. В приводимом ниже примере рассматриваются операции с матрицами, причем в зависимости от фактических параметров производится сложение, умножение, транспонирование и обращение матриц, а также создание единичной диагональной матрицы. При написании функций, отвечающих за транспонирование и сортировку, использовался алгоритм, описанный в книге (В.В. Подбельской. Язык С++. М.: Финансы и статистика. 1995). Помимо функции matrix(), производящей расчеты перегружена, также функция печати print(), выводящая на экран как вещественные, так и целочисленные массивы.

//==========================================================
// Name        : overload_multiplication.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;
#define n 4  //Порядок матриц
long i,j,k;
double Delta[n][n];
double Sigma[n][n];

int main() {
	//Умножение целочисленных матриц
	void matrix(int a[n][n], int b[n][n]);

	//Умножение вещественных матриц
	void matrix(double a[n][n], double b[n][n]);

	//Печать вещественнного двумерного массива
	void print (double c[n][n]);
	//Печать целочисленного двумерного массива
	void print (int c[n][n]);

	double ARRAY_X[n][n]={
						{1.1, 1.2, 1.3, 1.4},
						{1.5, 1.6, 1.7, 1.8},
						{1.9, 2.0, 2.1, 2.2},
						{2.3, 2.4, 2.5, 2.6}
						};

	double ARRAY_Y[n][n]={
						{3.1, 3.2, 3.3, 3.4},
						{3.5, 3.6, 3.7, 3.8},
						{3.9, 4.0, 4.1, 4.2},
						{4.3, 4.4, 4.5, 4.6}
						};

	int ARRAY_Z[n][n]={ {1,   3,  5,  7},
						{2,   4,  6,  8},
						{9,  11, 13, 15},
						{10, 12, 14, 16} };

	int ARRAY_W[n][n]={ {1,   2,  3,  4},
						{5,   6,  7,  8},
						{9,  10, 11, 12},
						{13, 14, 15, 16} };

	cout<<"\nFirst double matrix";
	print(ARRAY_X);
	cout<<"\nSecond double matrix";
	print(ARRAY_Y);
	cout<<"\nMultiplying";
	matrix(ARRAY_X,ARRAY_Y);
	print(Sigma);

	cout<<"\nFirst integer matrix";
	print(ARRAY_Z);
	cout<<"\nSecond integer matrix";
	print(ARRAY_W);
	matrix(ARRAY_Z,ARRAY_W);
	cout<<"\nMultiplying matrix";
	print(Delta);
	return 0;
}

////////////////////////////////////
//Умножение целочисленных матриц
/////////////////////////////////////
void matrix(int a[n][n], int b[n][n])
{
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			for(k=0;k<n;k++)
			{
				Delta[i][j]+=a[i][k]*b[k][j];
			}
		}
	}

}

/////////////////////////////////////
//Умножение вещественных матриц
/////////////////////////////////////
void matrix(double a[n][n], double b[n][n])
{
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			for(k=0;k<n;k++)
			{
				Sigma[i][j]+=a[i][k]*b[k][j];
			}
		}
	}

}

//////////////////////////////////////
//Печать целочисленного массива
/////////////////////////////////////
void print(int c[n][n])
{

for(i=0;i<n;i++)
{
	cout<<"\n";
	for(j=0;j<n;j++)
		{
			cout<<"\t"<<c[i][j];
		}

}
cout<<"\n"<<endl;
}

//////////////////////////////////////
//Печать вещественного массива
//////////////////////////////////////
void print(double c[n][n])
{

for(i=0;i<n;i++)
{
	cout<<"\n";
	for(j=0;j<n;j++)
		{
			cout<<"\t"<<c[i][j];
		}

}
cout<<"\n"<<endl;
}

Результат:

First double matrix
1.1 1.2 1.3 1.4
1.5 1.6 1.7 1.8
1.9 2.0 2.1 2.2
2.3 2.4 2.5 2.6
Second double matrix
3.1 3.2 3.3 3.4
3.5 3.6 3.7 3.8
3.9 4.0 4.1 4.2
4.3 4.4 4.5 4.6
Multiplying matrix
18.7 19.2 19.7 20.2
24.62 25.28 25.94 26.6
30.54 31.36 32.18 33
36.46 37.44 38.42 39.4
First integer matrix
1 3 5 7
2 4 6 8
9 11 13 15
10 12 14 16
Second integer matrix
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Multiplying matrix
152 168 184 200
180 200 220 240
376 424 472 520
404 456 508 560

В следующем примере рассматриваются две перегружаемые функции: сложения целочисленных матриц и создание единичной диагональной матрицы произвольного порядка (Подбельский). Функции с одинаковыми именами работают по разным алгоритмам.

//==========================================================
// Name        : overload_matrix.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;

#include<stdlib.h>

#define n 4  //Порядок матриц
int i,j;

////////////////////
int delta[n][n]; //
////////////////////

int main() {
	//Сложение двух вещественных матриц
	void matrix(int ARRAY_X[n][n], int ARRAY_Y[n][n]);

	//Создание единичной диагональной
	//матрицы изменяемого порядка
	void matrix(int m);

	//Печать целочисленного двумерного массива
	void print (int c[n][n]);

	//Матрицы a и b умножаются
	int a[n][n]={   {1,   3,  5,  7},
					{2,   4,  6,  8},
					{9,  11, 13, 15},
					{10, 12, 14, 16} };

	int b[n][n]={   {1,   2,  3,  4},
					{5,   6,  7,  8},
					{9,  10, 11, 12},
					{13, 14, 15, 16} };
	cout<<"\nFirst matrix";
	print(a);

	cout<<"\nSecond matrix";
	print(b);

	cout<<"\nAdding of two integer matrix";
	matrix(a,b);
	print(delta);

	cout<<"\nCreation of a single diagonal matrix of any order";
	matrix(n);
	return 0;
}

///////////////////////////////////////////////////////
//Сложение матриц
///////////////////////////////////////////////////////
void matrix(int ARRAY_X[n][n], int ARRAY_Y[n][n])
{
int s_x, s_y;

int *param_x[n];  // Вспомогательный массив указателей на первую матрицу
int *param_y[n];  // Вспомогательный массив указателей на вторую матрицу

for (i=0; i<n; i++)  // Цикл перебора строк
{
	param_x[i] = (int *)&ARRAY_X[i];
}

for (i=0; i<n; i++)  // Цикл перебора строк
{
	param_y[i] = (int *)&ARRAY_Y[i];
}

for(i=0;i<n;i++)
{
	for(j=0;j<n;j++)
	{
		s_x=param_x[i][j];
		s_y=param_y[i][j];
		delta[i][j]=s_x+s_y;
	}
}

}

///////////////////////////////////////////////
//Создание единичной диагональной
//матрицы произвольного порядка
//////////////////////////////////////////////
void matrix(int m)
{
	int **matr;      // Указатель для массива указателей
matr = new int *[n];// Массив указателей double *


if (matr == NULL)
{
	cout <<"The dinamic array doesn't created!";
	return;        // Завершение программы
}

for (int i=0;i<n;i++)
	{// Строка-массив значений типа double:
	matr[i]=new int[n];
	if (matr[i] == NULL)
	{cout << "The dinamic array doesn't created!";
	return;// Завершение программы
	}

		for (int j = 0; j < n; j++) // Заполнение матрицы
		// Формирование нулевых элементов:
		if (i !=j) matr[i][j] = 0;
		else
		// Формирование единичной диагонали:
		matr[i][j] = 1;
	}

for (i=0;i<n;i++)          // Цикл перебора строк
{
	cout<<"\n";// Цикл печати элементов строки:
		for (j=0;j<n;j++)
		cout << "\t" << matr[i][j];
}

for (i = 0; i < n; i++)
	delete matr[i];//Уничтожение матрицы
	delete[]matr;
	cout<<"\n"<<endl;

}
////////////////////////////////////////////////////////////

//////////////////////////////////////
//Печать целочисленного массива
/////////////////////////////////////
void print(int c[n][n])
{
	for(i=0;i<n;i++)
	{
		cout<<"\n";
		for(j=0;j<n;j++)
			{
				cout<<"\t"<<c[i][j];
			}

	}
}

Результат:

First integer matrix
1 3 5 7
2 4 6 8
9 11 13 15
10 12 14 16
Second matrix
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Adding of two integer matrix
2 5 8 11
7 10 13 16
18 21 24 27
23 26 29 32
Creation of a single diagonal matrix of any order
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
< Лекция 12 || Лекция 13 || Лекция 14 >
Зося Ковалева
Зося Ковалева

Хочу получить удостоверение. Сколько стоит оплата?