1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 |
namespace СalculatorKoltman { public partial class Form1 : Form { float a, b; int count; bool znak = true; private void calculate() { switch (count) { case 1: b = a + float.Parse(labelNum.Text); labelNum.Text = b.ToString(); break; case 2: b = a - float.Parse(labelNum.Text); labelNum.Text = b.ToString(); break; case 3: b = a * float.Parse(labelNum.Text); labelNum.Text = b.ToString(); break; case 4: b = a / float.Parse(labelNum.Text); labelNum.Text = b.ToString(); break; default: break; } } public Form1() { InitializeComponent(); labelNum.Text = "0"; labelAdd.Text = null; } private void NullNumber() { if ((labelNum.Text.IndexOf("0") == 0)) labelNum.Text = null; } private void button1_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "1"; } private void button2_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "2"; } private void button3_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "3"; } private void button4_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "4"; } private void button5_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "5"; } private void button6_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "6"; } private void button7_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "7"; } private void button8_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "8"; } private void button9_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "9"; } private void button0_Click(object sender, EventArgs e) { NullNumber(); labelNum.Text += "0"; } private void buttonP_Click(object sender, EventArgs e) { if ((labelNum.Text.IndexOf(",") == -1)) labelNum.Text += ","; } private void buttonC1_Click(object sender, EventArgs e) { int lenght = labelNum.Text.Length - 1; string text = labelNum.Text; labelNum.Text = null; for (int i = 0; i < lenght; i++) { labelNum.Text = labelNum.Text + text[i]; } } private void buttonC2_Click(object sender, EventArgs e) { labelNum.Text = null; labelNum.Text = "0"; } private void buttonC3_Click(object sender, EventArgs e) { labelNum.Text = labelAdd.Text = null; labelNum.Text = "0"; } private void buttonPlus_Click(object sender, EventArgs e) { a = float.Parse(labelNum.Text); labelNum.Text = null; count = 1; labelAdd.Text = a.ToString() + " +"; znak = true; labelNum.Text = "0"; } private void buttonMinus_Click(object sender, EventArgs e) { a = float.Parse(labelNum.Text); labelNum.Text = null; count = 2; labelAdd.Text = a.ToString() + " -"; znak = true; labelNum.Text = "0"; } private void buttonMult_Click(object sender, EventArgs e) { a = float.Parse(labelNum.Text); labelNum.Text = null; count = 3; labelAdd.Text = a.ToString() + " *"; znak = true; labelNum.Text = "0"; } private void buttonDiv_Click(object sender, EventArgs e) { a = float.Parse(labelNum.Text); labelNum.Text = null; count = 4; labelAdd.Text = a.ToString() + " /"; znak = true; labelNum.Text = "0"; } private void buttonEq_Click(object sender, EventArgs e) { calculate(); labelAdd.Text = ""; } private void buttonPM_Click(object sender, EventArgs e) { if(znak==true) { labelNum.Text = "-" + labelNum.Text; znak = false; } else if (znak == false) { labelNum.Text = labelNum.Text.Replace("-", ""); znak = true; } } private void Form1_Load(object sender, EventArgs e) { } private void labelAdd_Click(object sender, EventArgs e) { } private void labelNum_Click(object sender, EventArgs e) { } private void panel1_Paint(object sender, PaintEventArgs e) { } } } |
Improve Article
Save Article
Improve Article
Save Article
In C#, Math.Pow() is a Math class method. This method is used to calculate a number raise to the power of some other number.
Syntax:
public static double Pow(double base, double power)
Parameters:
double base: It is a double-precision floating-point number which is to be raised to a power and type of this parameter is System.Double.
double power: It is a double-precision floating-point number which specifies a power or exponent and type of this parameter is System.Double.
Return Type: The function returns the number base raised to the power. The type of this method is System.Double
Examples:
Input : base = 8, power =2 Output : 64 Input : base = 2.5, power =3 Output : 15.625
Program: To demonstrate the Math.Pow()
using System;
class GFG {
static public void Main()
{
double pow_ab = Math.Pow(6, 2);
Console.WriteLine(pow_ab);
double pow_tt = Math.Pow(3.5, 3);
Console.WriteLine(pow_tt);
double pow_t = Math.Pow(202, 4);
Console.WriteLine(pow_t);
}
}
Output:
36 42.875 1664966416
Reference: https://msdn.microsoft.com/en-us/library/system.math.pow(v=vs.110).aspx
Создадим программу, которая сможет возвести число в степень в консоли, используя метод Math.Pow.
Итак, создаем проект, затем объявляем две переменные.
Мы неоригинально назвали эти переменные a и b и указали их типом данных double — 64-разрядный тип повышенной точности с плавающей точкой, более функциональный, чем целочисленный int или менее точный float, но и занимающий больше памяти. В принципе, можно использовать любой тип из перечисленных — всё упирается в ваши нужды и запросы.
|
double a; double b; double c; |
Число с именем a мы будем возводить в число с именем b, а в с запишем результаты. Можно обойтись только a и b, наращивая a, но мы оставим её нетронутой для того, чтобы вывести в конце в WriteLine. Скоро вы всё поймёте.
Итак, для начала мы напишем доброжелательное сообщение для пользователя, который решит воспользоваться нашей программой:
|
Console.WriteLine(«Вас приветствует программа возведения числа в степень»); Console.WriteLine(«Пожалуйста, введите число, которое вы хотите возвести в степень:»); |
При запуске программы эти слова сразу же появятся в консоли.
Затем, по логике, пользователь вводит число для возведения в степень. Поэтому это число надо считать:
|
a = Convert.ToDouble(Console.ReadLine()); |
Мы конвертируем в тип double то, что написал нам наш пользователь.
Затем мы снова к нему обращаемся, уже с просьбой ввести степень, и так же считываем то, что он написал нам:
|
Console.WriteLine(«Спасибо, теперь введите степень, в которую хотите возвести число «+a+«:»); b = Convert.ToDouble(Console.ReadLine()); |
Заметьте, что и как написано в скобках метода Console.WriteLine. То, что находится в кавычках, выводится просто как текст. А между ними среди плюсов мы написали переменную а. Таким образом на консоль выведется ещё и значение, записанное в этой переменной.
Выглядеть это будет вот так:
Теперь настаёт момент выполнить саму операцию возведения в степень.
Для этого у нас в C# есть специальный метод Math.Pow.
Синтаксис у него такой:
То есть мы первое число в скобках возводим во второе число.
Теперь нам остаётся лишь вывести полученный результат.
Из-за него мы и не ввели переменную с, потому что вывод на консоль мы осуществили вот так:
|
Console.WriteLine(«Готово! «+a+» в степени «+b+» равно «+c+«!»); Console.ReadLine(); |
Визуально это выглядит вот так:
Мы ввели переменную с для того, чтобы в конце можно было вывести всё: и то, что в начале вводил пользователь, и сам результат.
Можно было и обойтись без введения третьей переменной, тогда вычисление выглядело бы вот так:
Тогда и вывод пришлось бы переделать примерно под это:
|
Console.WriteLine(«Готово! Результат равен «+a+«!»); Console.ReadLine(); |
Тут уже всё зависит от желания и умения программиста.
Вот и всё! Исходник программы находится ниже:
Скачать исходник
Для выполнения различных математических операций в библиотеке классов .NET предназначен класс Math. Он является статическим, поэтому все его методы также являются статическими.
Abs(double value): возвращает абсолютное значение для аргумента value
double result = Math.Abs(-12.4); // 12.4
Acos(double value): возвращает арккосинус value. Параметр value должен иметь значение от -1 до 1
double result = Math.Acos(1); // 0
Asin(double value): возвращает арксинус value. Параметр value должен иметь значение от -1 до 1
Atan(double value): возвращает арктангенс value
BigMul(int x, int y): возвращает произведение x * y в виде объекта long
double result = Math.BigMul(100, 9340); // 934000
Ceiling(double value): возвращает наименьшее целое число с плавающей точкой, которое не меньше value
double result = Math.Ceiling(2.34); // 3
Cos(double d): возвращает косинус угла d
Cosh(double d): возвращает гиперболический косинус угла d
DivRem(int a, int b, out int result): возвращает результат от деления a/b, а остаток помещается в параметр result
int result; int div = Math.DivRem(14, 5, out result); //result = 4 // div = 2
Exp(double d): возвращает основание натурального логарифма, возведенное в степень d
Floor(decimal d): возвращает наибольшее целое число, которое не больше d
double result = Math.Floor(2.56); // 2
IEEERemainder(double a, double b): возвращает остаток от деления a на b
double result = Math.IEEERemainder(26, 4); // 2 = 26-24
Log(double d): возвращает натуральный логарифм числа d
Log(double a, double newBase): возвращает логарифм числа a по основанию newBase
Log10(double d): возвращает десятичный логарифм числа d
Max(double a, double b): возвращает максимальное число из a и b
Min(double a, double b): возвращает минимальное число из a и b
Pow(double a, double b): возвращает число a, возведенное в степень b
Round(double d): возвращает число d, округленное до ближайшего целого числа
double result1 = Math.Round(20.56); // 21 double result2 = Math.Round(20.46); //20
Round(double a, int b): возвращает число a, округленное до определенного количества знаков после запятой, представленного параметром b
double result1 = Math.Round(20.567, 2); // 20,57 double result2 = Math.Round(20.463, 1); //20,5
Sign(double value): возвращает число 1, если число value положительное, и -1, если значение value отрицательное. Если value равно 0, то возвращает 0
int result1 = Math.Sign(15); // 1 int result2 = Math.Sign(-5); //-1
Sin(double value): возвращает синус угла value
Sinh(double value): возвращает гиперболический синус угла value
Sqrt(double value): возвращает квадратный корень числа value
double result1 = Math.Sqrt(16); // 4
Tan(double value): возвращает тангенс угла value
Tanh(double value): возвращает гиперболический тангенс угла value
Truncate(double value): отбрасывает дробную часть числа value, возвращаяя лишь целое значние
double result = Math.Truncate(16.89); // 16
Также класс Math определяет две константы: Math.E и Math.PI. Например, вычислим площадь круга:
Калькулятор Windows Forms на языке C#
Простой калькулятор Windows Forms на C#
Наш калькулятор основан на взаимодействии двух чисел, поэтому математические операции будут следующие:
Сложение
Вычитание
Умножение
Деление
Возведение первого числа в степень второго
Взятие корня первого числа степени второго числа.
Итак, после того, как с графическим оформлением закончено, приступаем к самому коду.
Для всех вышеописанных операций мы создадим отдельные функции. Функции – это, так сказать, подпрограммы в самой программе, выполняющие отдельные задачи. Они помогают сократить и облегчить код.
Функция сложения
public static double sum ( double a , double b )
{
return a + b ;
}
Для начала мы объявляем программе, что создаем функцию (пишем public static ), затем определяем тип функции( double – числовой тип повышенной точности с плавающей запятой, лучший вариант), после даём имя функции( sum ) и в скобках записываем то, что, так сказать, получает функция от программы( double a и double b – первое и второе числа, которые мы запишем в первые два TextBox’a ). Выражение return возвращает в функцию результат сложения a и b . То есть наша функция получает два числа от пользователя, который введет их в форме и, при помощи return’a , в неё же заносится результат вычисления.
Функция вычитания
public static double razn ( double a , double b )
{
return a — b ;
}
Функция умножения
public static double umnog ( double a , double b )
{
return a * b ;
}
Функция деления
public static double del ( double a , double b )
{
return a / b ;
}
Функция возведения в степень
public static double step ( double a , double b )
{
return Math . Pow ( a , b );
}
Функция извлечения корня
public static double koren ( double a , double b )
{
return Math . Pow ( a, 1/b );
}
Функции созданы, сталось лишь привязать их к кнопкам в форме. Дважды щёлкаем мышью в форме на первую кнопку. Нас переносит в часть кода, которая отвечает за событие, которое произойдет, когда пользователь кликнет на данную кнопку. В теле этого события мы пишем:
private void button1_Click(object sender, EventArgs e)
{
textBox3.Text = Convert.ToString(sum(Convert.ToDouble(textBox1.Text), Convert.ToDouble(textBox2.Text)));
}
Разбор кода начнём, как ни странно, с конца. Мы помним, что при объявлении функции мы писали вот такую часть кода: sum(double a, double b) . То есть функция может получить только значения типа double . Также мы помним, что эти значения мы получаем от пользователя, который, в свою очередь, вводит их в первый и второй TextBox’ы. Однако проблема в том, что значения из TextBox’ов воспринимаются программой как строки, то есть типом string . Поэтому их надо конвертировать в нужный нам double , что мы и делаем: sum(Convert.ToDouble(textBox1.Text),Convert.ToDouble(textBox2.Text))
private void button2_Click(object sender, EventArgs e)
{
textBox3.Text = Convert.ToString(razn(Convert.ToDouble(textBox1.Text), Convert.ToDouble(textBox2.Text)));
}
private void button3_Click(object sender, EventArgs e)
{
textBox3.Text = Convert.ToString(umnog(Convert.ToDouble(textBox1.Text), Convert.ToDouble(textBox2.Text)));
}
private void button4_Click(object sender, EventArgs e)
{
textBox3.Text = Convert.ToString(del(Convert.ToDouble(textBox1.Text), Convert.ToDouble(textBox2.Text)));
}
private void button5_Click(object sender, EventArgs e)
{
textBox3.Text = Convert.ToString(step(Convert.ToDouble(textBox1.Text), Convert.ToDouble(textBox2.Text)));
}
private void button6_Click(object sender, EventArgs e)
{
textBox3.Text = Convert.ToString(koren(Convert.ToDouble(textBox1.Text), Convert.ToDouble(textBox2.Text)));
}
Усложненный калькулятор
Здесь у нас 19 кнопок Button , 1 Textbox и ещё 1 пустой Label
Создаём форму. Увеличим ширину TextBox’a , используя MultiLine :
Также в Свойствах мы увеличили размер шрифта в TextBox’e и Label’e до 12 пт.
Теперь делаем так, чтобы при нажатии на цифровые кнопки, в TextBox’e появлялась соответствующая цифра.
Для этого дважды кликаем на кнопке “0” и в открывшемся коде пишем
private void button17_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 0;
}
private void button13_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 1;
}
private void button14_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 2;
}
private void button15_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 3;
}
private void button9_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 4;
}
private void button10_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 5;
}
private void button11_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 6;
}
private void button5_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 7;
}
private void button6_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 8;
}
private void button7_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + 9;
}
private void button18_Click(object sender, EventArgs e)
{
textBox1.Text = textBox1.Text + «,»;
}
float a, b;
int count;
bool znak = true;
Кнопки нажимаются, в TextBox’e отображаются нажатые цифры. Теперь надо научить программу производить с ними какие-либо операции. Как видно из формы, наш калькулятор сможет производить стандартные математические операции: сложение, вычитание, умножение и деление. Для начала мы создадим в самом начале программы несколько переменных, которые нам для этого понадобятся:
Кнопка «+»
Первым двум переменным будут присваиваться значения, набранные пользователем в калькуляторе. В последствии с ними будут производиться нужные математические операции. Тип float – это тип с плавающей точкой, позволяющий работать с десятичными дробями, что нам, безусловно, нужно при наличии кнопки “.” .
Благодаря второй переменной мы будем давать программе указания, какую именно операцию производить с переменными, описанными выше. Здесь нам не нужна дробь, поэтому обойдёмся целочисленным типом int .
Последняя переменная znak нам понадобится для того, чтобы менять знаки у введённых чисел. Тип bool может иметь два значения – ture и false . Мы представим, что если znak имеет значение true в программе, то это означает, что у числа знак + , если false – число отрицательное и перед собой имеет знак — . Изначально в калькуляторе вбиваются положительные числа, поэтому мы сразу присвоили переменной значение true .
Далее мы дважды нажимаем на кнопку “+” , обозначающую сложение, на форме и пишем следующий код:
Кнопка «-»
В строке 3 мы присваиваем первой переменной a то, что будет написано в TextBox’e (а именно число, которое введёт пользователь перед тем, как нажать кнопку “+” ).
Затем TextBox очищается, число, введённое пользователем, в нём пропадает (но остаётся в переменной a )
Переменной count присваивается число 1, которая потом укажет программе, что именно операцию сложения надо будет произвести с числами.
Затем в Label записывается число из переменной a (то самое, которое изначально ввёл пользователь) и знак плюса. Выглядеть в форме это будет так, как описано ниже.
Пользователь вводит какое-либо число:
Кнопка «*»
Кнопка «/»
Разница лишь в значении переменной count и в том, какой знак добавляется в Label’e .
Далее нам понадобится создать функцию, которая будет применять нужные нам математические операции к числам. Назовём её calculate . Но перед этим мы кликнем дважды на кнопку “=” на форме и в коде к ней мы запишем:
Кнопка «=»
То есть, при нажатии пользователем на кнопку “=” , как раз выполнится наша функция подсчёта calculate , и, заодно, очистится Label , так как результат мы в будущем коде выведем в TextBox .
Теперь-таки создаём нашу функцию calculate и пишем следующий код:
Здесь мы используем конструкцию switch-case .
Switch – это оператор управления. Он может включать в себя несколько case’ов . Case – метки, от значения которых зависит, какие операции будут происходить.
Строка switch(count) означает, что именно от значения count будет зависеть, какое действие будет происходить в коде switch’a .
Итак, если count=1 (в коде case 1: ), то произойдёт следующее:
После того, как пользователь нажал “+” , он, естественно, должен ввести второе слагаемое, что он и делает по стандартному сценарию, а затем нажать кнопку “=” (и в ней, как мы помним, как раз выполнится наша функция).
Как только кнопка “=” будет нажата, программа сложит число из переменной a с тем вторым слагаемым, которое записал пользователь в TextBox , и запишет результат в переменную b (строка 6 кода функции). В строке 7 программа выведет в TextBox результат сложения – переменную b .
Оператор break (строка 
завершает исполнение кода switch при выполнении кода метки case 1 , так как больше нам в нём делать нечего.
Точно так же строится алгоритм при case 2 , case 3 и case 4 с той разницей, что в них происходит не сложение, а вычитание, умножение и деление соответственно.
Оператор default срабатывает, если вдруг что-то пойдёт не по плану и count примет какое-либо иное значение, не описанное в switch . Тогда срабатывает лишь оператор break .
Львиная доля программы готова. Нам надо лишь написать код для трёх оставшихся нетронутыми до этого время кнопок.
Дважды жмём в форме на кнопку “С” . Она будет очищать все записи из TextBox’a и Label’a .
Кнопка «С»
Кнопка « »
Кнопка «+/-»
В данном уроке мы разработаем с вами калькулятор на C#. Программа будет написана согласно принципам объектно-ориентированного программирования (ООП): будет определен интерфейс для методов, реализующих функционал клавиш математических операций калькулятора, от интерфейса выполним наследование и напишем соответствующий класс и методы. Калькулятор, помимо базовых операций сложения, вычитания, умножения и деления, будет предоставлять возможность выполнять операции: извлечения квадратного корня, извлечения корня произвольной степени, возведения в квадрат, возведения в произвольную степень, вычисления факториала, а также работу с регистром памяти (MRC).
Создание интерфейса.
Создадим в Visual Studio проект на Visual C# Windows Forms. Добавим на форму элемент GroupBox, в который поместим Label. В свойстве Dock, элемента Label, необходимо указать Right, чтобы Label был привязан к правому краю. Связка данных элементов управления будет реализовывать дисплей калькулятора.
Калькулятор также содержит кнопки. Всего их 28 штук.
Программирование калькулятора на C#Реализация интерфейса класса.
Поскольку наш калькулятор будет написан в рамках парадигмы ООП (объектно-ориентированного программирования), то начнем кодирование с описания структуры интерфейса для класса, реализующего математические операции программы.
Добавим в проект класс InterfaceCalc.cs и определим в созданном файле интерфейс InterfaceCalc.
//интерфейс
public interface InterfaceCalc
{
//а — первый аргумент, b — второй
void Put_A(double a); //сохранить а
void Clear_A();
double Multiplication(double b);
double Division(double b);
double Sum(double b);
double Subtraction(double b); //вычитание
double SqrtX(double b);
double DegreeY(double b);
double Sqrt();
double Square();
double Factorial();
double MemoryShow(); //показать содержимое регистра памяти
void Memory_Clear(); //стереть содержимое регистра памяти
//* / + — к регистру памяти
void M_Multiplication(double b);
void M_Division(double b);
void M_Sum(double b);
void M_Subtraction(double b); //вычитание
}
Для выполнения математических операций понадобится два операнда: a и b (например, a + b). Операнд a придется хранить в памяти калькулятора, пока пользователь будет вводить второй аргумент операции. Для сохранения числа a объявим прототип метода void Put_A(double a), для очистки — void Clear_A(). Для умножения, деления, сложения и вычитания чисел a и b соответственно понадобятся методы: double Multiplication(double b), double Division(double b), double Sum(double b), double Subtraction(double b). Вычисление корня степени b из a: double SqrtX(double b). Возведение числа a в степень b: double DegreeY(double b). Вычисление квадратного корня: double Sqrt(). Возведение числа a в квадрат: double Square(). Вычисление факториала a!: double Factorial(). Теперь объявления методов для работы с регистром памяти (MRC) калькулятора. Показать содержимое памяти и очистить его: double MemoryShow(), void Memory_Clear(). M×, M÷, M+ и M- к регистру соответственно: void M_Multiplication(double b), void M_Division(double b), void M_Sum(double b), void M_Subtraction(double b).
Создание класса, реализующего интерфейс InterfaceCalc
Теперь добавим в калькулятор класс, который будет реализовывать написанный ранее интерфейс. Для этого в проекте создадим класс Calc : InterfaceCalc. Как вы видите, здесь используется наследование (оператор «двоеточие»). В данном классе напишем реализацию всех методов, требуемых спецификацией нашего интерфейса.
public class Calc : InterfaceCalc
{
private double a = 0;
private double memory = 0;
public void Put_A(double a)
{
this.a = a;
}
public void Clear_A()
{
a = 0;
}
public double Multiplication(double b)
{
return a * b;
}
public double Division(double b)
{
return a / b;
}
public double Sum(double b)
{
return a + b;
}
public double Subtraction(double b) //вычитание
{
return a — b;
}
public double SqrtX(double b)
{
return Math.Pow(a, 1 / b);
}
public double DegreeY(double b)
{
return Math.Pow(a, b);
}
public double Sqrt()
{
return Math.Sqrt(a);
}
public double Square()
{
return Math.Pow(a, 2.0);
}
public double Factorial()
{
double f = 1;
for (int i = 1; i <= a; i++)
f *= (double)i;
return f;
}
//показать содержимое регистра мамяти
public double MemoryShow()
{
return memory;
}
//стереть содержимое регистра мамяти
public void Memory_Clear()
{
memory = 0.0;
}
//* / + — к регистру памяти
public void M_Multiplication(double b)
{
memory *= b;
}
public void M_Division(double b)
{
memory /= b;
}
public void M_Sum(double b)
{
memory += b;
}
public void M_Subtraction(double b)
{
memory -= b;
}
}
Реализация работы калькулятора
Перейдем к написанию кода в классе Form1.
Объявим два поля:
CalcC;
int k;
Это классовая переменная C для класса Calc и целое число k. С помощью k будем считать количество нажатий кнопки MRC, чтобы при первом нажатии выводить значение регистра памяти на экран, а при последующем повторном — стирать значение регистра.
Далее. Нам понадобится ряд методов, которые будут обеспечивать правильное функционирование калькулятора.
Дисплеем в нашем калькуляторе является Label. Его содержимое — это строка текста. Нажатие на цифровые клавиши — это конкатенация текущего значения строки с символом клавиши. Необходимо исключить дублирование нулей в левой части строки (это делают 2-й и 3-й if в коде ниже), а также не допустить написание цифр, если в Label находится знак «бесконечность» (он появляется, например, при делении на ноль; 1-й if). Для решения данных проблем напишем метод CorrectNumber():
privatevoidCorrectNumber(){//если есть знак «бесконечность» — не даёт писать цифры после негоif(labelNumber.Text.IndexOf(«∞»)!=-1)labelNumber.Text=labelNumber.Text.Substring(0,labelNumber.Text.Length-1);//ситуация: слева ноль, а после него НЕ запятая, тогда ноль можно удалитьif(labelNumber.Text[0]==’0’&& (labelNumber.Text.IndexOf(«,») != 1)) labelNumber.Text = labelNumber.Text.Remove(0, 1);//аналогично предыдущему, только для отрицательного числаif(labelNumber.Text[0]==’-‘)if(labelNumber.Text[1]==’0’&& (labelNumber.Text.IndexOf(«,») != 2)) labelNumber.Text = labelNumber.Text.Remove(1, 1);}
Еще необходим метод, проверяющий: не нажата ли какая-нибудь кнопка калькулятора из математических операций, требующих два операнда. Данная проверка необходима для недопущения нажатия других мат. операций, если какая-либо уже нажата. Код метода CanPress():
privateboolCanPress(){if(!buttonMult.Enabled)returnfalse;if(!buttonDiv.Enabled)returnfalse;if(!buttonPlus.Enabled)returnfalse;if(!buttonMinus.Enabled)returnfalse;if(!buttonSqrtX.Enabled)returnfalse;if(!buttonDegreeY.Enabled)returnfalse;returntrue;}
Также, напишем вспомогательный метод FreeButtons(), который снимает нажатия со всех кнопок математических операций калькулятора, требующих два операнда (умножение, деление, сложение, вычитание, вычисление корня произвольной степени и возведение числа в произвольную степень):
privatevoidFreeButtons(){buttonMult.Enabled=true;buttonDiv.Enabled=true;buttonPlus.Enabled=true;buttonMinus.Enabled=true;buttonSqrtX.Enabled=true;buttonDegreeY.Enabled=true;}
Со вспомогательными методами закончили. Идем дальше.
В конструкторе Form1 создадим экземпляр класса Calc, а также в «дисплей» калькулятора занесем значение ноль.
publicForm1(){InitializeComponent();C=newCalc();labelNumber.Text=»0″;}
Теперь перейдем к кодированию обработчиков нажатий кнопок калькулятора. Кнопка «Очистка» (CE):
privatevoidbuttonClear_Click(objectsender,EventArgse){labelNumber.Text=»0″;C.Clear_A();FreeButtons();k=0;}
В «дисплей» записывается ноль, переменная a стирается, нажатия с кнопок математических операций снимаются и k обнуляется.
Кнопка изменения знака у числа «+/-«:
privatevoidbuttonChangeSign_Click(objectsender,EventArgse){if(labelNumber.Text[0]==’-‘)labelNumber.Text=labelNumber.Text.Remove(0,1);elselabelNumber.Text=»-«+labelNumber.Text;}
Кнопка «запятая» (будет добавлена, если ее еще нет и на «дисплее» нет знака бесконечность):
privatevoidbuttonPoint_Click(objectsender,EventArgse){if((labelNumber.Text.IndexOf(«,»)==-1)&& (labelNumber.Text.IndexOf(«∞») == -1)) labelNumber.Text += «,»;}
Теперь цифровые клавиши 0, 1, 2, 3, 4, 5, 6, 7, 8, 9:
privatevoidbutton0_Click(objectsender,EventArgse){labelNumber.Text+=»0″;CorrectNumber();}privatevoidbutton1_Click(objectsender,EventArgse){labelNumber.Text+=»1″;CorrectNumber();}privatevoidbutton2_Click(objectsender,EventArgse){labelNumber.Text+=»2″;CorrectNumber();}privatevoidbutton3_Click(objectsender,EventArgse){labelNumber.Text+=»3″;CorrectNumber();}privatevoidbutton4_Click(objectsender,EventArgse){labelNumber.Text+=»4″;CorrectNumber();}privatevoidbutton5_Click(objectsender,EventArgse){labelNumber.Text+=»5″;CorrectNumber();}privatevoidbutton6_Click(objectsender,EventArgse){labelNumber.Text+=»6″;CorrectNumber();}privatevoidbutton7_Click(objectsender,EventArgse){labelNumber.Text+=»7″;CorrectNumber();}privatevoidbutton8_Click(objectsender,EventArgse){labelNumber.Text+=»8″;CorrectNumber();}privatevoidbutton9_Click(objectsender,EventArgse){labelNumber.Text+=»9″;CorrectNumber();}
Кнопка «Равно»:
private void buttonCalc_Click(object sender, EventArgs e)
{
if (!buttonMult.Enabled)
labelNumber.Text = C.Multiplication(Convert.ToDouble(labelNumber.Text)).ToString();
if (!buttonDiv.Enabled)
labelNumber.Text = C.Division(Convert.ToDouble(labelNumber.Text)).ToString();
if (!buttonPlus.Enabled)
labelNumber.Text = C.Sum(Convert.ToDouble(labelNumber.Text)).ToString();
if (!buttonMinus.Enabled)
labelNumber.Text = C.Subtraction(Convert.ToDouble(labelNumber.Text)).ToString();
if (!buttonSqrtX.Enabled)
labelNumber.Text = C.SqrtX(Convert.ToDouble(labelNumber.Text)).ToString();
if (!buttonDegreeY.Enabled)
labelNumber.Text = C.DegreeY(Convert.ToDouble(labelNumber.Text)).ToString();
C.Clear_A();
FreeButtons();
k = 0;
}
В зависимости от того, какая из кнопок математических операций нажата, будет вызван соответствующий метод из класса Calc, вычисляющий данную функцию, и результат выведется в Label.
Далее кнопки математических операций. Сработают только в том случае, если другие в данный момент не нажаты (CanPress() вернет true):
//кнопка УмножениеprivatevoidbuttonMult_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));buttonMult.Enabled=false;labelNumber.Text=»0″;}}//кнопка ДелениеprivatevoidbuttonDiv_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));buttonDiv.Enabled=false;labelNumber.Text=»0″;}}//кнопка СложениеprivatevoidbuttonPlus_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));buttonPlus.Enabled=false;labelNumber.Text=»0″;}}//кнопка ВычитаниеprivatevoidbuttonMinus_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));buttonMinus.Enabled=false;labelNumber.Text=»0″;}}//кнопка Корень произвольной степениprivatevoidbuttonSqrtX_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));buttonSqrtX.Enabled=false;labelNumber.Text=»0″;}}//кнопка Возведение в произвольную степеньprivatevoidbuttonDegreeY_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));buttonDegreeY.Enabled=false;labelNumber.Text=»0″;}}//кнопка Корень квадратныйprivatevoidbuttonSqrt_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));labelNumber.Text=C.Sqrt().ToString();C.Clear_A();FreeButtons();}}//кнопка Квадрат числаprivatevoidbuttonSquare_Click(objectsender,EventArgse){if(CanPress()){C.Put_A(Convert.ToDouble(labelNumber.Text));labelNumber.Text=C.Square().ToString();C.Clear_A();FreeButtons();}}//кнопка ФакториалprivatevoidbuttonFactorial_Click(objectsender,EventArgse){if(CanPress()){if((Convert.ToDouble(labelNumber.Text)==(int)(Convert.ToDouble(labelNumber.Text)))&& ((Convert.ToDouble(labelNumber.Text) >= 0.0))) { C.Put_A(Convert.ToDouble(labelNumber.Text));labelNumber.Text=C.Factorial().ToString();C.Clear_A();FreeButtons();}elseMessageBox.Show(«Число должно быть >= 0 и целым!»);}}
Калькулятор вычислит факториал только в том случае, если текущее введенное число целое и больше, либо равно нулю.
Кнопки математических операций над регистром памяти (MRC):
//кнопка М+privatevoidbuttonMPlus_Click(objectsender,EventArgse){C.M_Sum(Convert.ToDouble(labelNumber.Text));}//кнопка М-privatevoidbuttonMMinus_Click(objectsender,EventArgse){C.M_Subtraction(Convert.ToDouble(labelNumber.Text));}//кнопка М*privatevoidbuttonMMult_Click(objectsender,EventArgse){C.M_Multiplication(Convert.ToDouble(labelNumber.Text));}//кнопка М/privatevoidbuttonMDiv_Click(objectsender,EventArgse){C.M_Division(Convert.ToDouble(labelNumber.Text));}
И последняя кнопка — «MRC». Она показывает содержимое регистра памяти на экран, а при повторном нажатии стирает его:
privatevoidbuttonMRC_Click(objectsender,EventArgse){if(CanPress()){k++;if(k==1)labelNumber.Text=C.MemoryShow().ToString();if(k==2){C.Memory_Clear();labelNumber.Text=»0″;k=0;}}}
На этом написание калькулятора на C# закончено. Спасибо за прочтение статьи!