Я новичок в программировании на C ++, но у меня есть опыт работы с Java. Мне нужно руководство о том, как передавать объекты в функции в C ++.

Нужно ли передавать указатели, ссылки или не указатели и не ссылки? Я помню, в Java нет таких проблем, поскольку мы передаем только переменную, которая содержит ссылку на объекты.

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

Практические правила для C ++ 11:

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

1. вам не нужно владеть объектом, и подойдет простой псевдоним, и в этом случае вы переходите по constссылке ,
2. Вы должны мутировать объект, и в этом случае используйте pass по constссылке без значения ,
3. Вы передаете объекты производных классов как базовые классы, и в этом случае вам нужно передать по ссылке . (Используйте предыдущие правила, чтобы определить, следует ли передавать по constссылке или нет.)

Передача по указателю практически никогда не рекомендуется. Необязательные параметры лучше всего выражать как std::optional( boost::optionalдля старых стандартных библиотек), а псевдонимы выполняются в порядке ссылки.

Семантика перемещения в C ++ 11 делает передачу и возврат по значению гораздо привлекательнее даже для сложных объектов.

Практические правила для C ++ 03:

Передавать аргументы по constссылке , кроме случаев, когда

1. они должны быть изменены внутри функции, и такие изменения должны быть отражены снаружи, и в этом случае вы переходите по constссылке
2. функция должна вызываться без каких-либо аргументов, в этом случае вы передаете указатель, чтобы пользователи могли передавать NULL// 0/ nullptr; примените предыдущее правило, чтобы определить, следует ли передавать указатель на constаргумент
3. они имеют встроенные типы, которые могут быть переданы копией
4. они должны быть изменены внутри функции, и такие изменения не должны отражаться снаружи, и в этом случае вы можете передать копию (альтернативой будет передача в соответствии с предыдущими правилами и создание копии внутри функции).

(здесь «передача по значению» называется «передача по копии», потому что передача по значению всегда создает копию в C ++ 03)

Есть еще кое-что, но правила этих нескольких начинающих помогут вам довольно далеко.

Существуют некоторые различия в соглашениях о вызовах в C ++ и Java. В C ++ с технической точки зрения существуют только два соглашения: передача по значению и передача по ссылке, причем некоторые литературные источники включают в себя третье соглашение о передаче по указателю (которое фактически является передачей по значению типа указателя). Кроме того, вы можете добавить константу к типу аргумента, улучшив семантику.

Передать по ссылке

Передача по ссылке означает, что функция концептуально получит экземпляр вашего объекта, а не его копию. Ссылка концептуально является псевдонимом объекта, который использовался в вызывающем контексте, и не может быть нулевым. Все операции, выполняемые внутри функции, применяются к объекту вне функции. Это соглашение не доступно в Java или C.

Передать по значению (и передать по указателю)

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

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

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

Добавление const к уравнению

В C ++ вы можете присваивать объектам постоянство при определении переменных, указателей и ссылок на разных уровнях. Вы можете объявить переменную постоянной, вы можете объявить ссылку на постоянный экземпляр, и вы можете определить все указатели на постоянные объекты, постоянные указатели на изменяемые объекты и постоянные указатели на постоянные элементы. И наоборот, в Java вы можете определить только один уровень константы (конечное ключевое слово): уровень переменной (экземпляр для примитивных типов, ссылка для ссылочных типов), но вы не можете определить ссылку на неизменный элемент (если только сам класс не является неизменный).

Это широко используется в соглашениях о вызовах C ++. Когда объекты маленькие, вы можете передать объект по значению. Компилятор сгенерирует копию, но эта копия не дорогая операция. Для любого другого типа, если функция не изменит объект, вы можете передать ссылку на постоянный экземпляр (обычно называемый постоянной ссылкой) типа. Это не скопирует объект, но передаст его в функцию. Но в то же время компилятор гарантирует, что объект не будет изменен внутри функции.

Эмпирические правила

Вот некоторые основные правила, которым нужно следовать:

• Предпочитать передачу по значению для примитивных типов
• Предпочитают передачу по ссылке со ссылками на константу для других типов
• Если функции необходимо изменить аргумент, используйте передачу по ссылке
• Если аргумент является необязательным, используйте переход по указателю (постоянный, если необязательное значение не должно быть изменено)

Существуют и другие небольшие отклонения от этих правил, первое из которых касается владения объектом. Когда объект динамически размещается с новым, он должен быть освобожден с удалением (или его версиями []). Объект или функция, которая отвечает за уничтожение объекта, считается владельцем ресурса. Когда динамически размещенный объект создается в фрагменте кода, но право собственности передается другому элементу, это обычно делается с помощью семантики передачи по указателю или, если возможно, с помощью интеллектуальных указателей.

Примечание

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

// C++
class Type; // defined somewhere before, with the appropriate operations
void swap( Type & a, Type & b ) {
   Type tmp = a;
   a = b;
   b = tmp;
}
int main() {
   Type a, b;
   Type old_a = a, old_b = b;
   swap( a, b );
   assert( a == old_b );
   assert( b == old_a ); 
}

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

public class C {
   // ...
   public static void swap( C a, C b ) {
      C tmp = a;
      a = b;
      b = tmp;
   }
   public static void main( String args[] ) {
      C a = new C();
      C b = new C();
      C old_a = a;
      C old_b = b;
      swap( a, b ); 
      // a and b remain unchanged a==old_a, and b==old_b
   }
}

Java-версия кода изменит копии ссылок внутри, но не изменит фактические объекты извне. Java-ссылки - это C-указатели без арифметики указателей, которые передаются по значению в функции.

Есть несколько случаев для рассмотрения.

Измененный параметр (параметры "out" и "in / out")

void modifies(T &param);
// vs
void modifies(T *param);

Этот случай в основном о стиле: вы хотите, чтобы код выглядел как call (obj) или call (& obj) ? Однако есть две точки, где разница имеет значение: необязательный случай, приведенный ниже, и вы хотите использовать ссылку при перегрузке операторов.

... и необязательно

void modifies(T *param=0);  // default value optional, too
// vs
void modifies();
void modifies(T &param);

Параметр не изменен

void uses(T const &param);
// vs
void uses(T param);

Это интересный случай. Практическое правило гласит, что типы «дешевого копирования» передаются по значению - обычно это небольшие типы (но не всегда), в то время как другие передаются по const ref. Однако, если вам нужно сделать копию внутри вашей функции независимо, вы должны передать по значению . (Да, это раскрывает некоторые детали реализации. C'est le C ++. )

... и необязательно

void uses(T const *param=0);  // default value optional, too
// vs
void uses();
void uses(T const &param);  // or optional(T param)

Здесь наименьшая разница между всеми ситуациями, так что выбирайте, что облегчит вашу жизнь.

Const by value - это деталь реализации

void f(T);
void f(T const);

Эти объявления на самом деле точно такая же функция! При передаче по значению const - это просто деталь реализации. Попробуйте это:

void f(int);
void f(int const) { /* implements above function, not an overload */ }

typedef void NC(int);       // typedefing function types
typedef void C(int const);

NC *nc = &f;  // nc is a function pointer
C *c = nc;    // C and NC are identical types

Передать по значению:

void func (vector v)

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

Недостатком являются циклы процессора и дополнительная память, затрачиваемая на копирование объекта.

Передать по константной ссылке:

void func (const vector& v);

Эта форма эмулирует поведение передачи по значению при удалении издержек копирования. Функция получает доступ на чтение к исходному объекту, но не может изменять его значение.

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

Передать по неконстантной ссылке:

void func (vector& v)

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

Как и в случае с константным ссылочным кодом, он не является поточно-ориентированным.

Передать по константному указателю:

void func (const vector* vp);

Функционально аналогичен передаче по const-reference, за исключением другого синтаксиса, плюс тот факт, что вызывающая функция может передавать указатель NULL, чтобы указать, что она не имеет допустимых данных для передачи.

Не потокобезопасен.

Передать по неконстантному указателю:

void func (vector* vp);

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

void func (string* str, /* ... */) {
    if (str != NULL) {
        *str = some_value; // assign to *str only if it's non-null
    }
}

Как и все, передаются по ссылке / указателю, а не потокобезопасны.

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

Class CPlusPlusJavaFunctionality {
    public:
       CPlusPlusJavaFunctionality(){
         attribute = new int;
         *attribute = value;
       }

       void setValue(int value){
           *attribute = value;
       }

       void getValue(){
          return *attribute;
       }

       ~ CPlusPlusJavaFuncitonality(){
          delete(attribute);
       }

    private:
       int *attribute;
}

void changeObjectAttribute(CPlusPlusJavaFunctionality obj, int value){
   int* prt = obj.attribute;
   *ptr = value;
}

int main(){

   CPlusPlusJavaFunctionality obj;

   obj.setValue(10);

   cout<< obj.getValue();  //output: 10

   changeObjectAttribute(obj, 15);

   cout<< obj.getValue();  //output: 15
}

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

Существует три способа передачи объекта в функцию в качестве параметра:

1. Передать по ссылке
2. передать по значению
3. добавление константы в параметр

Просмотрите следующий пример:

class Sample
{
public:
    int *ptr;
    int mVar;

    Sample(int i)
    {
        mVar = 4;
        ptr = new int(i);
    }

    ~Sample()
    {
        delete ptr;
    }

    void PrintVal()
    {
        cout << "The value of the pointer is " << *ptr << endl
             << "The value of the variable is " << mVar;
   }
};

void SomeFunc(Sample x)
{
cout << "Say i am in someFunc " << endl;
}


int main()
{

  Sample s1= 10;
  SomeFunc(s1);
  s1.PrintVal();
  char ch;
  cin >> ch;
}

Вывод:

Скажи, что я в someFunc
Значение указателя -17891602
Значение переменной 4

Ниже приведены способы передачи аргументов / параметров для работы в C ++.

1. по стоимости.

// passing parameters by value . . .

void foo(int x) 
{
    x = 6;  
}

2. по ссылке.

// passing parameters by reference . . .

void foo(const int &x) // x is a const reference
{
    x = 6;  
}

// passing parameters by const reference . . .

void foo(const int &x) // x is a const reference
{
    x = 6;  // compile error: a const reference cannot have its value changed!
}

3. по объекту.

class abc
{
    display()
    {
        cout<<"Class abc";
    }
}


// pass object by value
void show(abc S)
{
    cout<<S.display();
}

// pass object by reference
void show(abc& S)
{
    cout<<S.display();
}