How to Keep a Reference to Another Object in the Parameters of the Class

How to keep a reference to another object in the parameters of the class

In Swift objects are generally passed by reference, and only stuff like strings, ints, ... are passed by value... (Also structs are passed by value too!!!)

That means you don't need to create a special pointer to your object... If you just pass an object you already have set a pointer to the object (not a copy)

class TestClass {
    var name: String?
}

class SecondTestClass {
    var testClass: TestClass?
}

var testClass = TestClass()

var secondTestClass = SecondTestClass()
secondTestClass.testClass = testClass

testClass.name = "Worked"

var stringInObject = secondTestClass.testClass?.name

NSLog("\(stringInObject)")

And you are done :-)

How to write a constructor that takes a reference to a class, which points to an object in Java?

It basically means that your constructor takes in another object of the same class, and instantiates a new object using its values.

public GeometricObject(final GeometricObject other){
    this.color = other.color;
    this.filled = other.filled;
    //copy other member variables
}

Then, if you have an object, you can create a copy of it like this:

final GeometricObject geometricObject = new GeometricObject();
//do stuff to geometricObject, give values to variables, etc
final GeometricObject copy = new GeometricObject(geometricObject);

How to call a method with parameters as objects from another class java?

The problem was that I was trying to add an object of the same class Member to call the method from the other class Website, which had a Member purchase as a parameter.

So in order to correctly call that method, I used this code:

    public void payForHoliday(Holiday test) 
    {
       website.checkout(this, test);
    }

• For pointing to the method checkout() in the Website class, I used an address(Website website) declared as an instance variable in Member class.

• The this keyword tells the program that the parameter is the object itself, which is calling The method.

• The test variable is placed as a parameter due to the fact that is a pointer from another class. (I changed the variable name to another name to avoid conflicts with the one in the checkout() method)

Object passed as parameter to another class, by value or reference?

Objects will be passed by reference irrespective of within methods of same class or another class. Here is a modified version of same sample code to help you understand. The value will be changed to 'xyz.'

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    public class Employee
    {
        public string Name { get; set; }
    }

    public class MyClass
    {
        public Employee EmpObj;

        public void SetObject(Employee obj)
        {
            EmpObj = obj;
        }
    }

    public class Program
    {
       static void Main(string[] args)
        {
            Employee someTestObj = new Employee();
            someTestObj.Name = "ABC";

            MyClass cls = new MyClass();
            cls.SetObject(someTestObj);

            Console.WriteLine("Changing Emp Name To xyz");
            someTestObj.Name = "xyz";

            Console.WriteLine("Accessing Assigned Emp Name");
            Console.WriteLine(cls.EmpObj.Name); 

           Console.ReadLine();
       }       
    }
 }

Passing an object by reference and storing it as a member variable

Short answer: You can't. The simple reason is that GameState::a and the object passed by reference to GameState::init are distinct objects, they will never be the same.

Now, let's talk about ways to fix this in an "idiomatic C++" way:

Firstly, think about what GameState::init() means. It is a call on an instance of class GameState, which only writes to a static class property. Why doesn't it write to the instance's property? This smells a bit as if GameState::a was effectively a global variable, which inherits all its badness.

As a different approach, pass dependencies (like the parameter to init()) into the constructor (a.k.a. "Dependency Injection"). Then, you can initialize a reference to that parameter with the injected dependency:

class GameState {
    public:
    GameState(A& a): m_a(a) {}

    private:
    A& m_a;
};

Note that you must make sure that the A instance outlives the GameState instance. In some cases, where you have to dynamically allocate things and where you don't need them outside any more, passing ownership via a smart pointer (std::unique_ptr) is desirable, you can then replace the reference with such a smart pointer.

passing object by reference in C++

What seems to be confusing you is the fact that functions that are declared to be pass-by-reference (using the &) aren't called using actual addresses, i.e. &a.

The simple answer is that declaring a function as pass-by-reference:

void foo(int& x);

is all we need. It's then passed by reference automatically.

You now call this function like so:

int y = 5;
foo(y);

and y will be passed by reference.

You could also do it like this (but why would you? The mantra is: Use references when possible, pointers when needed) :

#include <iostream>
using namespace std;

class CDummy {
public:
    int isitme (CDummy* param);
};

int CDummy::isitme (CDummy* param)
{
    if (param == this) return true;
    else return false;
}

int main () {
    CDummy a;
    CDummy* b = &a;             // assigning address of a to b
    if ( b->isitme(&a) )        // Called with &a (address of a) instead of a
        cout << "yes, &a is b";
    return 0;
}

Output:

yes, &a is b

---

Related Topics