Как передать массив char в функцию c

Передача элемента символьного массива в функцию с изменением значения

Как мне передать символьный массив mass[30] в функцию, чтобы при вызове функции function() в массиве находилось слово «Something» ?

Отслеживать
10.8k 1 1 золотой знак 18 18 серебряных знаков 34 34 бронзовых знака
задан 5 мая 2020 в 20:44
1 1 1 серебряный знак 6 6 бронзовых знаков
Я ничего не понял.
5 мая 2020 в 20:55
Вам нужно в функцию передать пустой массив так, чтобы после её вызова в нём появилась строка?
5 мая 2020 в 21:00

@КириллМалышев мне необходимо передать в функцию function мой символьный массив mass[30]. Это делается для того, чтобы изменить его содержимое, но если я передам его как есть, изменения не сохранятся, значит надо изменять адрес, но как сделать это с символьным массивом я без понятия

5 мая 2020 в 21:01
@RomanMitasov да, но не факт что этот массив будет пустым, если это имеет значение
5 мая 2020 в 21:02

Массив передаётся в функцию по адресу. Если вы его там измените, то эти изменения и после выхода из функции будут. Только у вас сигнатура функции неправильная, нужно передавать char *a.

5 мая 2020 в 21:02

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Во-первых, вам надо изменить тип параметра функции:

function (char* a)

или function (char a[])

Потом при вызове функции передавайте массив в неё вот так:

void function(char a[]) < strcpy_s(a, "Something"); >int main ()

Пояснение

Добавление к типу * делает этот тип указателем. Советую просто найти литературу или просто поискать в гугле про «указатели в C++».

Но если вкратце — char a это тип «символ», а char* a это тип «указатель на символ» или «адрес ячейки в памяти, в которой лежит символ».

Когда мы работаем с массивами в Си и C++, мы можем указывать вместо char* char[] . Квадратные скобки семантически говорят программисту, что это не просто указатель, а указатель на начало массива. Со стороны программы запись char* и char[] совершенно одинакова. Проще говоря — это синтаксический сахар для лучшей читаемости программ.

Именно поэтому, когда нужно сделать функцию, которая что-то делает с переменной или массивом снаружи (то есть пришедшем в параметре), надо всегда делать тип параметра этой функции указателем или ссылкой.

Про ссылки расписывать не буду, ищи-читай на просторах интернета.

Передача массивов в функции

Здесь рассмотрена операция по передаче массивов в качестве аргументов функции, поскольку существуют исключения из стандартного правила передачи по значению.

Когда массив используется в качестве аргумента функции, передается только адрес массива, а не копия всего массива. При вызове функции с именем массива в функцию передается указатель на первый элемент массива. (Надо помнить, что в С имена массивов без индекса — это указатели на первый элемент массива.) Параметр должен иметь тип, совместимый с указателем. Имеется три способа объявления параметра, предназначенного для получения указателя на массив. Во-первых, он может быть объявлен как массив, как показано ниже:

#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(), модифицируется, после возврата он будет содержать набранные символы.

Передать массив char, в функцию

Добрый день, не понемаю как можно в собственную функцию передать массив char. Собственно есть 2 примера, можете подсказать правильные или же нет? Укажите пожалуйста на ошибки. Среда VS2012. Я только просто начал изучать функции.

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

//1 #include using namespace std; int Max=5; void input(char v[],int n); void output(char b[],int m); int main(){ char nas[Max]; input(nas,Max);//ввод output(nas,Max);//вывод return 0; } void input(char v[],int n){ for(int i=0;in;i++){ cout<"Введите элементы = "<(i+1); cin>>v[i]; } } void output(char b[],int m){ for(int i=0;im;i++){ cout<"Индекс "<(i+1)<", элемент= "[i]; } }

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

//2 #include using namespace std; void input(char c[],int n); void output(char h[], int o); int main(){ char * vio= new char[5]; input(vio,5);//ввод output(vio,5);//вывод delete [] vio; return 0; } void input(char c[],int n){ for(int i=0;in;i++){ cout<"Элемент "<(i+1); cin>>c[i]; } } void output(char h[], int o){ for(int i=0;io;i++){ cout<"Ваши элементы "[i]; } }

Передача массива в функцию, подсчет длины массива по указателю

В С++ массивы можно инициализировать следующим образом:

int arr[] = ; // длина массива определяется после инициализации

Как следствие, его можно передать в функцию таким же способом:

void func(int arr[])< //your code >

void func(int* arr) < //your code >int arr[5] = ;

Мы привыкли обращаться к элементам массива по индексам, но попробуйте скомпилировать и запустить следующие строки:

int main()< int arr[5] = ; cout 

void func(int* arr, int length)< //your code >

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

int len(int* arr)

Крайне важно понять критерий по которому мы будем оценивать содержимое. В противном случае, можно получить не совсем то, что ожидалось.