|
Хочу получить удостоверение. Сколько стоит оплата? |
Опубликован: 10.12.2015 | Доступ: свободный | Студентов: 610 / 92 | Длительность: 07:10:00
Тема: Программирование
Специальности: Программист, Системный архитектор
Лекция 13:
Перегрузка функций
< Лекция 12 || Лекция 13 || Лекция 14 >
Ключевые слова: перегрузка, операции, сложение, умножение, транспонирование, алгоритм, статистика, matrix, функция, print
Перегрузка функций используется для того, чтобы функции с одним и тем же именем выполнялись по-разному в зависимости от типа и количества фактических параметров.
Для обеспечения перегрузки функций необходимо для каждого имени определить, сколько разных функций связано с ним, т.е. сколько вариантов сигнатур допустимы при обращении к ним. В приводимом ниже примере рассматриваются операции с матрицами, причем в зависимости от фактических параметров производится сложение, умножение, транспонирование и обращение матриц, а также создание единичной диагональной матрицы. При написании функций, отвечающих за транспонирование и сортировку, использовался алгоритм, описанный в книге (В.В. Подбельской. Язык С++. М.: Финансы и статистика. 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;
}
Результат:
| 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 |
В следующем примере рассматриваются две перегружаемые функции: сложения целочисленных матриц и создание единичной диагональной матрицы произвольного порядка (Подбельский). Функции с одинаковыми именами работают по разным алгоритмам.
//==========================================================
// 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];
}
}
}
Результат:
< Лекция 12 || Лекция 13 || Лекция 14 >
