Можно ли в switch-case сверять с массивом?
Возник такой вопрос. Пишу бота-помощника для сайта и нужно анализировать фразы посетителей, но их может быть великое множество вариаций, поэтому возник вопрос, а можно ли в case вместо одного значения поставить сразу массив и сравнивать с этим массивом ответов? И если хоть одно значение совпадет, выполнять этот case
Отслеживать
задан 3 мая 2017 в 20:50
3,169 2 2 золотых знака 22 22 серебряных знака 44 44 бронзовых знака
кажется документация, вполне ясно описывает синтаксис и возможности оператора switch . Приведите какой-нибудь пример кода, и возможно вам подскажут, как оптимизировать его написание
3 мая 2017 в 20:58
можно. но скорее всего нужно делать совсем другое.
3 мая 2017 в 21:18
@АлексейШиманский, а что?
3 мая 2017 в 22:12
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
Можно. Но это выглядит как не верный подход. Поиск совпадения в массиве достаточно затратная операция, а вы предлагаете искать в нескольких массивах. Если подойти к вопросу чисто академически, то код будет выглядеть примерно вот так:
$var = 'Hello'; $var = strtolower($var); $array1 = array('hello', 'hi', 'yo'); $array2 = array('what', 'where', 'when'); switch (true) < case in_array($var, $array1): //do something break; case in_array($var, $array2): //do something else break; >Отслеживать
ответ дан 4 мая 2017 в 6:47
486 5 5 серебряных знаков 15 15 бронзовых знаков
Можете посоветовать способ делать это быстрей и менее затратно?
4 мая 2017 в 6:54
@So-so , я не знаком с вашей предметной областью, но мне кажется более подходящим вариантом использование легковесной базы данных, где поиск будет происходить по подготовленной фразе (strtolower, htmlspecialchars и подобное). Если свести все вразы к ключам то можно использовать NoSQL решения, если нет то MySQL.
Как вносить switch case в массив си
Регистрация: 04.11.2012
Сообщений: 22
Перемещение из case 1 в case 2(switch(), язык Си)
Привет всем, кто читает данную тему. Уже благодарен за то,что вы тратите свое время на чужие проблемы
Суть проблемы:
Значит имеется КУСОК кода(первый кейс в функции switch()), в котором объявлены 2 динамических массива. Оба созданы для какой-либо строки, то есть символьные. 1-ый я создал здоровым, что бы туда точно поместился тот текст, который введет пользователь. 2-ой же массив я создаю уже после того, как известно кол-во символов, которые взбредут в голову пользователю. Мы с помощью функции strcpy() перекидываем содержимое большого массива(1-ого) в маленький ,уже подстроенный под определенное кол-во символов. Все работает замечательно, прям сказка, но. приходит время использовать 2-ой массив во 2-ом кейсе этого свича. Но она объявлена в 1-ом, то есть локальная. Вопрос:нужно каким-либо способом засунуть данные во 2-ой кейс и что бы(желательно) все работало. Я понимаю, что легче сделать так, что бы вынести объявление за свитч и использовать во всех кейсах, НО!, узнаю сколько символов я только в момент отработки кода 1-ого кейса, то есть сначала она у меня равна 0(и если вынести создается массив с 0 символами). Причина, почему я не могу вынести этот код за границы кейса тоже простая: у меня в начале программы есть высвечивается в виде менюшки( её то я и сделал с помощью switch()).
И именно в первом кейсе у меня подразумевается ввод текста, а во 2-ом уже работа над этим текстом( то есть над моим динамич. массивом).
Вот код:
switch(vibor) < case 1: < couttext_1[count_simbol] = '\0'; //tut char *text = new char[count_simbol]; strcpy_1(text, text_1); printf("%s", text); getchar(); delete []text_1; break; > case 2: < //сюда бы и нужно занести массив text[count_simbol] break; >^Вот мои 2 кейса, описанные выше.
код в первом кейсе работает нормально, поэтому меня интересует лишь заданный мною вопрос. Заранее спасибо за ответ. Буду признателен за помощь.
Как вносить switch case в массив си
Массив представляет набор однотипных данных. Формальное определение массива выглядит следующим образом:
тип_переменной название_массива [длина_массива]
После типа переменной идет название массива, а затем в квадратных скобках его размер. Например, определим массив из 4 чисел:
int numbers[4];
Число элементов массива также можно определять через константу:
const int n = 4; int numbers[n]; // содержит 4 элемента
Некоторые компиляторы (например, G++) также поддерживают установку размера с помощью переменных.
Данный массив имеет четыре числа, но все эти числа имеют неопределенное значение. Чтобы установить значения элементов массива, указываются фигурные скобки (инициализатор), внутри которых перечисляются значения для элементов массива:
int numbers[4] <>; //
В данном случае фигурные скобки пусты, поэтому все элементы массива получают нулевые значения.
Также мы можем указать конкретные значения для всех элементов массива:
int numbers[4] ;
В данном случае в памяти выделяется некоторая область из четырех ячеек по 4 байта (размер типа int), где каждая ячейка содержит определенный элемент массива:
Если значений в инициализаторе меньше, чем элементов в массиве, то значения передаются первым элементам, а остальные получают нулевые значения:
int numbers[4] ; //
Если значений в инициализаторе больше, чем элементов в массиве, то при компиляции возникнет ошибка:
int numbers[4] ; // ! Ошибка
Здесь массив имеет размер 4, однако ему передается 6 значений.
Если размер массива не указан явно, то он выводится из количества переданных значений:
int numbers[] ;
В данном случае в массиве есть 6 элементов.
При этом не допускается присвоение одному массиву другого массива:
int nums1[] ; int nums2[] = nums1; // ошибка
Индексы. Получение и изменение элементов массива
После определения массива мы можем обратиться к его отдельным элементам по индексу. Индексы начинаются с нуля, поэтому для обращения к первому элементу необходимо использовать индекс 0. Обратившись к элементу по индексу, мы можем получить его значение, либо изменить его. Например, получим второй элемент (индекс 1):
int n = numbers[1];
Изменение значения второго элемента:
numbers[1] = 123;
Например, получим и изменим значения элементов:
#include int main() < int numbers[4]; int first = numbers[0]; // получаем первый элемент std::cout
При обращении по индексу следует учитывать, что мы не можем обратиться по несуществующему индексу. Так, если в массиве 4 элемента, то мы можем использовать индексы с 0 до 3 для обращения к его элементам. Использование любого другого индекса приведет к ошибке:
int numbers[4]; int forth = numbers[4]; // !Ошибка - в массиве только 4 элемента
Константные массивы
Если необходимо, чтобы нельзя было изменять значения элементов массива, то такой массив можно определить как константный с помощью ключевого слова const
const int numbers[4]; // numbers[1] = 23; // ошибка - значения элементов массива изменить нельзя
Длина массива
Длина массива не всегда бывает известна. Однако может потребоваться получить ее. Для этого можно использовать несколько способов. Первый способ, который пришел из языка С, представляет применение оператора sizeof :
#include int main() < int numbers[]; std::cout
По сути длина массива равна совокупной длине его элементов. Все элементы представляют один и тот же тип и занимают один и тот же размер в памяти. Поэтому с помощью выражения sizeof(numbers) находим длину всего массива в байтах, а с помощью выражения sizeof(numbers[0]) - длину одного элемента в байтах. Разделив два значения, можно получить количество элементов в массиве.
Второй способ представляет применение встроенной библиотечной функции std::size() :
#include int main() < int numbers[]; int count = std::size(numbers); std::cout
Перебор массивов
Используя циклы, можно пробежаться по всему массиву и через индексы обратиться к его элементам:
#include int main() < const int n = 4; int numbers[n] ; for(int i=0; i < n; i++) < std::cout >
Чтобы пройтись по массиву в цикле, надо знать его длину. Здесь длина задана константой n.вначале надо найти длину массива. И в цикле for перебираем все элементы, пока счетчик i не станет равным длине массива. В итоге на консоль будут выведены все элементы массива:
11 12 13 14
Другой пример - вычислим сумму элементов массива:
#include int main() < int numbers[]; int sum <>; for (int i <>; i < std::size(numbers); sum += numbers[i++]); std::cout
Здесь длина массива вычисляется динамически - с помощью функции std::size() .
Перебор элементов в стиле for-each
Используем другую форму цикла for , которая предназначена специально для перебора последовательностей, в том числе для массивов
#include int main() < int numbers[4] ; for(int n : numbers) < std::cout >
При переборе массива каждый перебираемый элемент будет помещаться в переменную number, значение которой в цикле выводится на консоль.
Если нам неизвестен тип объектов в массиве, то мы можем использовать спецификатор auto для определения типа:
for(auto n : numbers)
Ввод значений массива с консоли
Подобно тому, как вводятся данные для отдельных переменных, можно вводить значения для отдельных элементов массива. Например, пусть пользователь вводит значения числового массива:
#include int main() < const int max ; // максимальная длина массива - не больше 6 чисел int numbers[max]; // массив для ввода чисел int i<>; // счетчик введенных чисел std::cout > numbers[i]; // вводим число i++; > // выводим массив for (i =0; i < max; ++i) < std::cout std::cout
Здесь в цикле сначала вводятся шесть чисел для каждого элемента массива, затем выводим этот массив.
Передача массивов в функции
Здесь рассмотрена операция по передаче массивов в качестве аргументов функции, поскольку существуют исключения из стандартного правила передачи по значению.
Когда массив используется в качестве аргумента функции, передается только адрес массива, а не копия всего массива. При вызове функции с именем массива в функцию передается указатель на первый элемент массива. (Надо помнить, что в С имена массивов без индекса - это указатели на первый элемент массива.) Параметр должен иметь тип, совместимый с указателем. Имеется три способа объявления параметра, предназначенного для получения указателя на массив. Во-первых, он может быть объявлен как массив, как показано ниже:
#include
void display(int num[10]);
int main (void) /* вывод чисел */
int t [10], i;
for (i=0; i display(t);
return 0;
>
Хотя параметр num объявляется как целочисленный массив из десяти элементов, С автоматически преобразует его к целочисленному указателю, поскольку не существует параметра, который мог бы на самом деле принять весь массив. Передается только указатель на массив, поэтому должен быть параметр, способный принять его.
Следующий способ состоит в объявлении параметра для указания на безразмерный массив, как показано ниже:
где num объявлен как целочисленный массив неизвестного размера. Поскольку С не предоставляет проверку границ массива, настоящий размер массива не имеет никакого отношения к параметру (но, естественно, не к программе). Данный метод объявления также определяет num как целочисленный указатель.
Последний способ, которым может быть объявлен num, - это наиболее типичный способ, применяемый при написании профессиональных программ, - через указатель, как показано ниже:
Он допустим, поскольку любой указатель может быть индексирован с использованием [], если он является массивом. (На самом деле массивы и указатели очень тесно связаны друг с другом.) Все три метода объявления параметра приводят к одинаковому результату - указателю. С другой стороны, элемент массива используется как аргумент, трактуемый как и другие простые переменные. Например, программа может быть написана без передачи всего массива:
void display(int num)
printf ("%d ", num);
>
Как можно видеть, в display() передается параметр типа int. Не имеет значения, что display() вызывается с элементом массива в качестве параметра, поскольку передается только одно значение.
Важно понять, что при использовании массива в качестве аргумента функции происходит передача в функцию его адреса. Это означает, что код внутри функции действует и может изменять настоящее значение массива, используемого при вызове. Например, рассмотрим функцию print_upper(), выводящую строку прописными буквами:
#include
#include
void print_upper(char *string);
int main(void) /* вывод строки в верхнем регистре */
char s[80];
gets (s);
print_upper(s) ;
return 0;
>
void print_upper(char *string)
register int t;
for(t=0; string[t]; ++t)
string[t] = toupper(string[t]);
printf("%c", string[t]);
>
>
После вызова print upper() происходит изменение содержимого массива s в main(). Если это не нужно, следует переписать программу следующим образом:
# include
#include
void print upper(char *string);
int main(void) /* вывод строки в верхнем регистре */
char s[80];
gets(s);
print_upper(s);
return 0;
>
void print_upper(char *string)
register int t;
for(t=0; string[t]; ++t)
printf ("%c", toupper (string[t]));
>
В данной версии содержимое массива s остается неизменным, поскольку значения не меняются.
Классический пример передачи массивов в функции находится в стандартной библиотечной функции gets(). Хотя gets() из библиотеки Borland С++ гораздо сложнее, функция, показанная в данном примере, содержит основную идею работы. Для того, чтобы избежать путаницы и не вызвать стандартную функцию, данная функция называется xgets().
/* простейшая версия стандартной библиотечной функции gets() */
void xgets (char *s)
register char ch;
register int t;
for(t=0; t ch = getche();
switch(ch)
case ' \r':
s[t] = '\0'; /* null завершает строку */
return;
case '\b':
if(t>0) t-;
break;
default:
s[t] = ch;
t++;
>
>
s[79] = ' \0';
>
Функция xgets() должна вызываться с указателем на символ. Это может быть имя символьного массива, который по определению является указателем на символ. xgets() организует цикл for от 0 до 79. Таким образом предотвращается ввод больших строк с клавиатуры. Если набирается более 80 символов, функция завершает работу. Поскольку C не имеет проверки границ массива, следует убедиться, что массив, передаваемый в xgets(), может принять, по крайней мере, 80 символов. По мере набора символов на клавиатуре они вводятся в строку. Если набирается забой, счетчик t уменьшится на 1. При нажатии на ввод помещается нулевой символ в конец строки, то есть строка оканчивается. Поскольку массив, используемый при вызове xgets(), модифицируется, после возврата он будет содержать набранные символы.