Параметры функции в C++ для начинающих

Опубликовано 03.05.2012 | Автор: admin

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

Многие новички, изучающие языки программирования, тяжело переходят на работу с функциями. Язык С++ имеет свои особенности, которые могут мешать осознанию новичками происходящего в процессе написания кем-то кода. Часть этих особенностей касается параметров функций.

Вам сразу нужно научиться различать термины параметры функции и аргументы функции. Различать эти термины несложно.

Аргументы и параметры могут называть не тем способом, которым я называю в своей статье. Это не ошибка, просто разные авторы пишут по-разному.

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

анимированная картинка, показывающая, что такое параметры функции и что такое аргументы функции

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

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

Параметр с типом ссылка или указатель — влияет на аргумент, уходящий в функцию.

Параметр с обычным типом — не влияет на уходящий в функцию аргумент.

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

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

Это самое главное отличие: в одном случае изменения, происходящие внутри функции, легко влияют на ушедший в функцию аргумент, в другом случае ушедший в функцию аргумент остаётся самим собой и не зависит от параметра, его принявшего.

Это всё нужно посмотреть в коде, и вы легко поймёте, о чём идёт речь:

//Borland C++ 3.1       Влияние типов параметров на уходящий в функцию аргумент         Листинг #1
#include <iostream.h>

void foo1(int value) {    value = value + 1;     }      //У параметра обычный тип
void foo2(int& value){    value = value + 1;     }      //У параметра ссылочный тип
void foo3(int* value){    *value = *value + 1;   }      //У параметра указательный тип

int main()
{
    int x = 100;

    foo1(x);
    cout << "foo1, x == " << x << '\n'; //100       //x не изменился (обычный тип параметра, нет влияния)

    foo2(x);
    cout << "foo2, x == " << x << '\n'; //101       //x изменился   (ссылочный тип параметра повлиял)

    foo3(&x);
    cout << "foo3, x == " << x << '\n'; //102       //x изменился   (указательный тип параметра повлиял)

    foo1(x);
    cout << "foo1, x == " << x << '\n'; //102       //x не изменился    (обычный тип параметра, нет влияния)

    foo1(x);
    cout << "foo1, x == " << x << '\n'; //102       //x не изменился   (обычный тип параметра, нет влияния)

    cin.get();
}

//Borland C++ 3.1 Влияние типов параметров на уходящий в функцию аргумент Листинг #1

#include <iostream.h>

void foo1(int value) { value = value + 1; } //У параметра обычный тип

void foo2(int& value){ value = value + 1; } //У параметра ссылочный тип

void foo3(int* value){ *value = *value + 1; } //У параметра указательный тип

int main()

{

int x = 100;

foo1(x);

cout << "foo1, x == " << x << '\n'; //100 //x не изменился (обычный тип параметра, нет влияния)

foo2(x);

cout << "foo2, x == " << x << '\n'; //101 //x изменился (ссылочный тип параметра повлиял)

foo3(&x);

cout << "foo3, x == " << x << '\n'; //102 //x изменился (указательный тип параметра повлиял)

foo1(x);

cout << "foo1, x == " << x << '\n'; //102 //x не изменился (обычный тип параметра, нет влияния)

foo1(x);

cout << "foo1, x == " << x << '\n'; //102 //x не изменился (обычный тип параметра, нет влияния)

cin.get();

}

Только не перепутайте параметры и аргументы. Различие параметров и аргументов — ключ к пониманию этой статьи в целом.

Для понимания оставшейся части статьи необходимо знать:

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

//Отличие параметра указательного характера от параметра ссылочного характера
//ПРИМЕР UB!
#include <iostream>

using namespace std;


void foo1(int *value){      //параметр с указательным типом
    value = new int(100);
}

void foo2(int* &value){     //параметр с ссылочным типом
    value = new int(100);
}

int main()
{
    int *x = 0;



    foo2(x);
    cout << "foo2, *x = " << *x << '\n';    //100
    delete x;

    foo1(x);
    cout << "foo1, *x = " << *x << '\n';   //что-то странное  в лучшем случае
    delete x;

    cin.get();
}

//Отличие параметра указательного характера от параметра ссылочного характера

//ПРИМЕР UB!

#include <iostream>

using namespace std;

void foo1(int *value){ //параметр с указательным типом

value = new int(100);

}

void foo2(int* &value){ //параметр с ссылочным типом

value = new int(100);

}

int main()

{

int *x = 0;

foo2(x);

cout << "foo2, *x = " << *x << '\n'; //100

delete x;

foo1(x);

cout << "foo1, *x = " << *x << '\n'; //что-то странное в лучшем случае

delete x;

cin.get();

}

Показываемый пример на самом деле ведёт к непрогнозируемому поведению программы. Попробуйте поменять вызовы foo1 и foo2 местами (внутри main), программа скорее всего сработает ужасно, полезут какие-нибудь ошибки. Дело в том, что для вывода на экран используется аргумент-указатель, состояние которого не было изменено созданным внутри функции клоном указательного аргумента, память выделилась для клона, но не для ушедшего вовнутрь функции аргумента, а потом delete используется для оригинального аргумента, к которому не было применено new. Тут вам и утечка памяти и неправильное использование delete для указателя (delete применяется только в паре с new). Исключение — нулевой указатель, к нему можно применять delete. Если область памяти была выделена операцией new, то можно на эту область памяти направить любой подходящий по типу указатель и применить к этой области delete. Но в коде существует две указательные переменные и аргумент, ушедший в функцию, ничем не перенаправляется на участок памяти, выделенный посредством клона. А потом к аргументу, который указывает на участок памяти, который не выделялся с помощью new используется delete, т. е. происходит попытка разрушить память, которую рушить нельзя.

В С++ можно создавать ссылку на указатель, но нельзя создавать указатель на ссылку.

В списке параметров, где используется параметр с ссылочным типом, на самом деле используется ссылка на указательную переменную, указывающую на тип int (читайте подобные синтаксические изыски справа-налево, и вам будет легче их понимать). Ссылочная переменная напрямую влияет на аргумент, ушедший в функцию, поэтому выделение памяти операцией new внутри функции foo2 повлияло на указательную переменную x, уходящую в функцию как аргумент, и выделение памяти для параметра value оказалось выделением памяти непосредственно для x.

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

int main()
{
    int value1 = 100;
    int value2 = 200;

    int *x1 = &value1;
    int *x2 = x1;        //Указатель инициализируется указателем

    x1 = &value2;

    cout << *x1 <<' ' << *x2;       //указатели разошлись: 100 200

    cin.get();
}

int main()

{

int value1 = 100;

int value2 = 200;

int *x1 = &value1;

int *x2 = x1; //Указатель инициализируется указателем

x1 = &value2;

cout << *x1 <<' ' << *x2; //указатели разошлись: 100 200

cin.get();

}

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

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

Когда параметр функции не ссылочен, внутри функции создаётся новая переменная, которая является локальной для функции копией пришедшего в функцию аргумента.

Когда параметр функции представляет собой ссылку, то никаких новых переменных внутри функции не создаётся, и работа с аргументом, пришедшим в функцию, происходит напрямую.

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

Вопрос, должный появляться у очень многих новичков может звучать приблизительно так: "А когда нужно использовать параметры с ссылочным типом и когда с обычным типом?". Ответ на этот вопрос достаточно прост: при работе с большими объектами данных лучше использовать ссылочный тип параметров, а при работе с маленькими объектами лучше использовать обычный тип для параметров. Понять, что такое большой объект и маленький объект новичкам понять бывает сложно. Типы состоят из простых типов: int, double, char и составных типов: массивы, структуры, классы. Большие объекты, это объекты, которые строятся из нескольких типов. Например, массив строится из множества ячеек одного типа, это большой объект. В классе или структуре для создания объекта совмещают несколько нужных типов, объекты таких классов или структур — это большие объекты. Можете продолжать аналогию, суть в том, что если для описания какой-то сущности нужно использовать много объединённых типов, то такой тип стоит считать большим, а если используется примитивный тип данных, просто сам по себе, то этот тип считается маленьким.

Использование ссылочного типа для параметра функции помогает избегать накладных расходов на выполнение операций копирования в больших объектах.

Если вы возьмёте, например, строку, то она по сути массив, а массив — это сущность, состоящая из множества однотипных элементов, т. е. строка — это большой объект. В случае создания клона строки каждый символ оригинальной строки будет копироваться в созданный клон, а это отнимает время. Поэтому логичнее использовать параметр функции ссылочного характера для приёма аргумента строки, чем использовать параметр нессылочного характера. Из-за ссылочного характера параметра клон строки создан не будет, и операций по копированию символов просто не будет нужно выполнять компилятору, просто имя параметра свяжется с оригинальной строкой и это всё.

Меня достаточно долго интересовал вопрос: Почему во многих книгах в функциях параметры описываются как константные ссылки, и почему разные опытные программисты ругаются на новичков, забывающих дописать квалификатор const к параметру функции? Наиболее часто встречаемый довод: "Вы так убережёте себя от своих же ошибок".

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

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

//Простейший пример защиты себя от непредвиденных ошибок:
#include <iostream>

using namespace std;


int foo(int &a, int &b){
   if (a = b) return 1; //использование =, вместо ==
   return 0;
}

int main(){
    int value1 = 5;
    int value2 = 10;

    if (foo) cout << value1 << " == " << value2 << '\n';
    else cout << value1 << " != " << value2 << '\n';

    cin.get();
}

//Простейший пример защиты себя от непредвиденных ошибок:

#include <iostream>

using namespace std;

int foo(int &a, int &b){

if (a = b) return 1; //использование =, вместо ==

return 0;

}

int main(){

int value1 = 5;

int value2 = 10;

if (foo) cout << value1 << " == " << value2 << '\n';

else cout << value1 << " != " << value2 << '\n';

cin.get();

}

В последнем примере неразумно использовать параметр ссылочного характера, но чтобы вам было проще, я решил использовать именно этот пример. Мы пишем много функций, которые не предназначены для изменений, в таких случаях нужно обязательно добавлять к параметрам, которые мы не намерены изменять, квалификатор const. Если бы мы сразу учли, что коли функция сравнивает две сущности и ничего изменять не должна в принципе, то добавили бы const, и этот код просто бы не стал компилироваться, таким образом мы уберегли бы себя задолго до возможного возникновения похожей ситуации.

ЗАПОМНИТЕ! const — ваш друг!

//Теперь код не будет компилироваться, и найти ошибку будет проще
#include <iostream>

using namespace std;


int foo(const int &a, const int &b){
   if (a = b) return 1; //использование =, вместо ==
   return 0;
}

int main(){
    int value1 = 5;
    int value2 = 10;

    if (foo) cout << value1 << " == " << value2 << '\n';
    else cout << value1 << " != " << value2 << '\n';

    cin.get();
}

//Теперь код не будет компилироваться, и найти ошибку будет проще

#include <iostream>

using namespace std;

int foo(const int &a, const int &b){

if (a = b) return 1; //использование =, вместо ==

return 0;

}

int main(){

int value1 = 5;

int value2 = 10;

if (foo) cout << value1 << " == " << value2 << '\n';

else cout << value1 << " != " << value2 << '\n';

cin.get();

}

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

Рубрика: Функции

Anonymous:

29.08.2012 в 3:55 пп

"Первый вариант можно привести ко второму или третьему, если например, объявить глобальную переменную (int z), после этого внутри функции присвоить в нее полученную x, а после вызова функции из тела программы написать value=x"Наверно, надо написать value=z, так как через глобальную переменную z в данном случае передаётся выходная информация функции.

Ответить

bazikmaloj:

02.05.2013 в 2:18 пп

а как написать функцию по вычисление целых чисел умножение! в языке С#

Аноним:

15.11.2013 в 10:19 пп

Все разжовано, и досупно. огромное спасибо. Где можно найти сборник ваших статей?

Автор сайта отвечает:
Пожалуйста)
Про сборник статей не понял чего-то. Если это вопрос про содержание списка тем сайта, то главная страница. Сайт ci-plus-plus-snachala.ru

04.01.2014 в 1:14 пп

автор спасибо большое за статью, но учите орфографию и пишите чуть короче. успехов )

Автор сайта отвечает:
писать короче — означает убрать какие-то моменты. Гораздо больше людей нуждаются в таком стиле изложения материалов, где пусть будет больше описано, но чтобы понятно стало, чем в стиле, где пусть будет кратко и только то, что нужно. Это все-таки не справочник для умеющих, а сайт для начинающих.
А по поводу орфографии вы не правы. Что мне и стоило бы учить, так это правила пунктуации. Слова я пишу достаточно грамотно, а знаки препинания расставляю не так, как должно быть. Пунктуация — знаки препинания. Орфография — правильное написание слов.

25.01.2014 в 1:42 дп

Здравствуйте, помогите, пожалуйста с заданием, никак не могу вникнуть в суть -_-
Написать программу, вычисляющую сумму всех положительных чисел, введённых с клавиатуры, и номер первого положительного числа.
Например, при вводе с клавиатуры чисел: -1, -2, -3, 0, 0, 0, 1, 2, 3 сумма равна 6, номер первого положительного равен 7.
Функция main: 1. вызывает функцию inout; 2. выводит запрос на продолжение работы и в соответствии с ответом пользователя производит дальнейшие действия.
Функция inout: 1. объявляет переменную int i; 2. передаёт переменную i по указателю функции func; 3. выводит на экран результат работы.
Функция func: 1. получает указатель на переменную i; 2. запрашивает и i получает неопределённое количество чисел, вводящихся с клавиатуры; 3. переменной присваивается номер первого положительного элемента; 4. вычисляет сумму положительных элементов и возвращает вычисленную сумму.

Автор сайта отвечает:

C++

#include <iostream> #include <locale.h> using namespace std; int func(int *i) //Функция принимает указатель на переменную типа int { static int first_pol=0; //Позиция первого положительного элемента static int flag_first_pol=0; //Признак того, что положительный элемент уже есть static int sum=0; //Сумма всех положительных элементов if (*i>0) //В том случае, если принятый параметр положительное число { flag_first_pol=1; //Обозначаем, что было положительное число sum=sum+*i; //Суммируем его с последним результатом суммы положительных чисел } if (!flag_first_pol) first_pol++; //Если положительных чисел не было, то наращиваем счетчик позиции cout<<"Сумма положительных чисел = "<<sum<<"\n"; //Выводим на экран сумму всех положительных чисел if (!flag_first_pol) return 0; //Если положительных чисел не было, то возвращаем ноль, а не счетчик else return first_pol+1; //если положительные были, то возвращаем счетчик, который наращивали + единичка (чтобы отсчет с одного был) } int inout() { int i=0; cout<<"Введи i: "; cin>>i; cout<<"Номер первого положительного числа = "<<func(&i)<<"\n"; //Здесь выводим на экран результат работы func (позицию первогого положительного элемента) return 0; } int main() { setlocale(LC_ALL,""); int my_variant=1; //Переменная для выбора действия while (my_variant) //Пока переменная не ноль будет выполнятся цикл, предлагающий выбор действия { inout(); //Выполняется функция inout cout<<"Повторить = 1, Закончить=0 "; //Выбор действия cin>>my_variant; cout<<"\n"; } }

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

#include <iostream>
#include <locale.h>

using namespace std;

int func(int *i)  //Функция принимает указатель на переменную типа int
{
    static int first_pol=0;      //Позиция первого положительного элемента
    static int flag_first_pol=0;  //Признак того, что положительный элемент уже есть
    static int sum=0;  //Сумма всех положительных элементов

       if (*i>0)  //В том случае, если принятый параметр положительное число
       {
         flag_first_pol=1;  //Обозначаем, что было положительное число
         sum=sum+*i;  //Суммируем его с последним результатом суммы положительных чисел
       }

       if (!flag_first_pol) first_pol++; //Если положительных чисел не было, то наращиваем счетчик позиции

    cout<<"Сумма положительных чисел = "<<sum<<"\n";  //Выводим на экран сумму всех положительных чисел
    if (!flag_first_pol) return 0;  //Если положительных чисел не было, то возвращаем ноль, а не счетчик
    else return first_pol+1; //если положительные были, то возвращаем счетчик, который наращивали + единичка (чтобы отсчет с одного был)
}

int inout()
{
  int i=0;
    cout<<"Введи i: ";
    cin>>i;
    cout<<"Номер первого положительного числа = "<<func(&i)<<"\n";  //Здесь выводим на экран результат работы func (позицию первогого положительного элемента)
  return 0;
}

int main()
{
  setlocale(LC_ALL,"");
  int my_variant=1;  //Переменная для выбора действия

  while (my_variant)  //Пока переменная не ноль будет выполнятся цикл, предлагающий выбор действия
  {
      inout(); //Выполняется функция inout
    cout<<"Повторить = 1, Закончить=0 ";  //Выбор действия
    cin>>my_variant;
    cout<<"\n";
  }
}

Wao-Bao:

04.04.2015 в 11:21 дп

Е-мое!!! Можно же просто и толково объяснить. После кучи статей наконец понял механизм передачи параметров.

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

(как прототип :))))))) Спасибо !

Harrix:

04.05.2015 в 4:25 пп

В функции srav допущена ошибка. Там при сравнении используется один знак равно, а не два, как нужно.

admin:

04.05.2015 в 6:48 пп

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

Ответить

Shurkec:

03.12.2015 в 12:51 пп

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

void array_calc(int a[][10], int height, int width) {
for (int i = 0; i < height; ++i) {
for (int j = 0; j < width; ++j) {
a[i][j] = a[i][j] * 2;
printf("%i  %c", a[i][j],' ');
}
printf("\n");
}
return;
}

void array_calc(int a[][10], int height, int width) {

for (int i = 0; i < height; ++i) {

for (int j = 0; j < width; ++j) {

a[i][j] = a[i][j] * 2;

printf("%i %c", a[i][j],' ');

printf("\n");

return;

Эту функцию вызываю так (ввод/вывод значений массива я опустил):

int main() {
int mat[5][5];

array_calc (mat, 5, 5);
}

int mat[5][5];

array_calc (mat, 5, 5);

Так вот — после вызова этой функции значения массива mat меняются, а мне этого к примеру не нужно. Или значения массивов передаются именно как ссылки?

admin:

03.12.2015 в 1:09 пп

Массив из функции вернуть нельзя.
При передаче массива в функцию, имя массива неявно приводится к указателю на первый элемент этого массива. Так как получается эффект получения параметра по указателю, то копии массива не делается. Поэтому все изменения внутри функции действуют и на него. Варианты решения: использовать обьект класса или структуры, использовать вектор, использовать обьект array(c++11), или руками делать внутри функции новый массив и копироаать в него данные для следующей обработки.

Ответить

Vitek Beluy:

12.01.2016 в 11:47 пп

а можно теперь как-то сделать к этому счетчик количества вызова функций?

admin:

13.01.2016 в 12:50 дп

Можно
Глобальной переменной
Статической переменной
Передачей параметра по ссылке
Передачей указателя на массив
Сохранением в файл
Другими способами…

Ответить

Валерий:

01.10.2016 в 10:49 дп

меня интересует иное. Как функция знает соответствие входных переменных внутренним переменным в её теле.

admin:

01.10.2016 в 4:06 пп

Мы сами ей говорим в момент её вызова, что мы в ней извне использовать станем. У неё два варианта: использовать извне что-то напрямую или использовать извне не напрямую. Это мы говорим сами, говорим, когда внутри функции выбираем, как будем использовать параметры (по ссылке или нет). В общем, сама она знает ровно столько, сколько мы ей сказали знать.

Не очень понял вопрос, но надеюсь ответ получился понятным.
1. Место вызова функции.
2. Параметры функции.

Ответить

Николай:

31.01.2017 в 12:01 пп

Скажите пожалуйста, что с ней не так???

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int g[12][12], I;
double srp[12], sro[12];

void func(int arr[], int num, double &sp, double &so)
{
double s1 = 0.0, s2 = 1.0, k1 = 0.0, k2 = 0.0;
for (int i = 0; i < I; i++) {
if (arr[i] > 0) {
k1 += 1.0;
s1 += arr[i];
}
if (arr[i] < 0) {
k2 += 1.0;
s2 *= arr[i];
}
}
sp = (k1 == 0) ? 0.0 : (s1/k1);
so = (k2 == 0) ? 0.0 : pow(s2, 1/k2);
}

int main()
{
scanf(«%d», &I);
for (int i = 0; i < I; i++)
for (int j = 0; j < I; j++)
scanf(«%d», &g[i][j]);
for (int i = 0; i < I; i++) func(g[i], i, srp[i], sro[i]);
for (int i = 0; i < I; i++) {
for (int j = 0; j < I; j++) printf(«%d\t», g[i][j]);
printf(«%lf\n», srp[i]);
}
for (int i = 0; i < I; i++) printf(«%lf\n»,sro[i]);
return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int g[12][12], I;

double srp[12], sro[12];

void func(int arr[], int num, double &sp, double &so)

double s1 = 0.0, s2 = 1.0, k1 = 0.0, k2 = 0.0;

for (int i = 0; i < I; i++) {

if (arr[i] > 0) {

k1 += 1.0;

s1 += arr[i];

if (arr[i] < 0) {

k2 += 1.0;

s2 *= arr[i];

sp = (k1 == 0) ? 0.0 : (s1/k1);

so = (k2 == 0) ? 0.0 : pow(s2, 1/k2);

scanf(«%d», &I);

for (int i = 0; i < I; i++)

for (int j = 0; j < I; j++)

scanf(«%d», &g[i][j]);

for (int i = 0; i < I; i++) func(g[i], i, srp[i], sro[i]);

for (int j = 0; j < I; j++) printf(«%d\t», g[i][j]);

printf(«%lf\n», srp[i]);

for (int i = 0; i < I; i++) printf(«%lf\n»,sro[i]);

Почему компилятор выдает мне это?

C:\Users\USER\Desktop\Hashtag_Zvukooperator\exam\main.c:8:38: error: expected ‘;’, ‘,’ or ‘)’ before ‘&’ token
void func(int arr[], int num, double &sp, double &so)

admin:

31.01.2017 в 1:02 пп

Без понятия. Если компилятор C++, должно работать.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int g[12][12], I;
double srp[12], sro[12];

void func(int arr[], int num, double &sp, double &so)
{
    double s1 = 0.0, s2 = 1.0, k1 = 0.0, k2 = 0.0;
    for (int i = 0; i < I; i++)
    {
        if (arr[i] > 0)
        {
            k1 += 1.0;
            s1 += arr[i];
        }
        if (arr[i] < 0)
        {
            k2 += 1.0;
            s2 *= arr[i];
        }
    }
    sp = (k1 == 0) ? 0.0 : (s1/k1);
    so = (k2 == 0) ? 0.0 : pow(s2, 1/k2);
}

int main()
{
    scanf("%d", &I);
    for (int i = 0; i < I; i++)
        for (int j = 0; j < I; j++)
            scanf("%d", &g[i][j]);
    for (int i = 0; i < I; i++) func(g[i], i, srp[i], sro[i]);
    for (int i = 0; i < I; i++)
    {
        for (int j = 0; j < I; j++) printf("%d\t", g[i][j]);
        printf("%lf\n", srp[i]);
    }
    for (int i = 0; i < I; i++) printf("%lf\n",sro[i]);
    return 0;
}

if (arr[i] > 0)

if (arr[i] < 0)

scanf("%d", &I);

scanf("%d", &g[i][j]);

for (int j = 0; j < I; j++) printf("%d\t", g[i][j]);

printf("%lf\n", srp[i]);

for (int i = 0; i < I; i++) printf("%lf\n",sro[i]);

Дима:

15.03.2017 в 12:13 дп

Какой из способов передачи параметров расходует больше памяти?

Ответить
- admin:
  
  15.03.2017 в 11:24 дп
  
  Если в функцию отдаётся маленький объект (double, int, char…), то одинаково быстро.
  Если в функцию отдаётся большой объект (класс, структура), то по указателю и ссылке одинаково быстрее, чем по значению.
  
  Ответить

Дмитрий:

17.09.2017 в 7:19 дп

Николай, компилятор сообщает вам: «Ожидаю ‘;’, ‘,’ или ‘)’ до ‘&'». А теперь внимательно посмотрите текст своей программы: и func, и pow, и main, и scanf, и printf выделены коричневым цветом. Из чего я делаю вывод: ваша функция func конфликтует с библиотечной func, в которой ВСЕГО ДВА параметра, а язык, почему-то, не позволяет выполнить перегрузку (переопределение) функции (хотя, насколько мне известно, в C++ такая возможность реализована). Советую вам сменить имя функции на другое. У меня в Arduino IDE текст вашей программы компилируется без ошибок!
Творческих вам успехов!
С уважением, Дмитрий.

Ответить

Последние комментарии

Александр к записи Хороший стиль программирования
Аноним к записи Список тем сайта
Аноним к записи Список тем сайта

Параметры функции в C++ для начинающих

19 комментариев на «“Параметры функции в C++ для начинающих”»

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета