Im trying to reference my array in another function but i keep getting errors.
void player::store()
{
int menuChoice;
int amountChoice = 0;
int items[4] = {0,0,0,0};
string inv;
[Code]...
errors
C:UsersChayDesktopDinosaur ArenaMainGame.h|81|error: declaration of 'items' as array of references|
C:UsersChayDesktopDinosaur ArenaMainGame.h|81|error: prototype for 'void player::backpack(...)' does not match any in class 'player'|
C:UsersChayDesktopDinosaur Arenaplayer.h|24|error: candidate is: void player::backpack()|
I suspect the syntax of the declaration, but I am not sure what to do here? If I change the call to the function, then the array ( matrix ) is passed by value, and it takes forever:
Code: int read_files(std::string fname, int nCols, int nRows, ss_matrix_t ssMat ) // this takes ages ( it does compile and link )
Now when I want to access that array, I have the following:
ptrSomeStruct->structArray[someIndex];
But now I want to pass structArray to this function by reference so that it can adjust the array as needed and I can continue to use the array back in my caller function:
so I'm trying to rework some code that solves sets of equations by gaussian elimination and wanted to change the array elements to pointers. Below i've put my c code and the custom header file that goes with it.
Header file
#ifndef CHAPTER5_8_H #define CHAPTER5_8_H #define N 5 #define INPUT_FILENAME "equations.txt"
I just started learning about pointer and reference. * and &
The assignment is " Write a program that stores the following numbers in the array named miles:15,22,16,18,27,23, and 20. Have your program copy the data stored in miles to another array named dist, and then display the values in the dist array. YOur program should use pointer notation when copying and displaying array elements.
And this is what i have so far. But there is an error. I highlighted it with red. It says it's incompatible...
#include <iostream> using namespace std; const int arraynumb = 7; // declaration of keys: number of characters of keys void copyfunc(int *[], int); // function initialized int main() { int miles[arraynumb] = {15, 22, 16, 18, 27, 23, 20};
When you pass an entire array as an argument into a function, it passes by reference. When you modify the reference in the function, it also modifies the value in the calling function, even without returning a value. This is because references edit the same memory address, rather than creating a copy of it (passing by value).
This code shows an example of an array being passed by reference into a function, being modified, and printed out back in the main function:
void myFunction(int refArray[], const int valMAX_ARRAY) { int x = 0; while (x < valMAX_ARRAY) { refArray[x] = refArray[x] * 3; ++x;
[code]....
OUTPUT
33 99 135
Coupling is how much multiple functions depend on the same variables. When using globals for instance, the program may become error-prone or difficult to follow if many different functions can modify the same values.
My question is this - Doesn't tight coupling occur when passing arguments by reference? If you pass the same array to multiple functions, all functions are modifying the same information. Isn't this the same as working with globals?
Second question - Since arguments being passed by value will "copy" a memory address rather than allow the function to modify the same information, isn't this bad on performance? Isn't it the same as initializing new variables within the body of the function? Doesn't this create more memory offsets every time the function is run?
Write a complete C++ program with the two alternate functions specified below, each of which simply triples the variable count defined in main. Then compare and contrast the two approaches. These two functions are
a) function tripleByValue that passes a copy of count by value, triples the copy and returns the new value and
b) function tripleByReference that passes count by reference via a reference parameter and triples the original value of count through its alias (i.e., the reference parameter).
Code: #include <iostream> #include <vector> using namespace std;
class A{
[Code]....
I read somewhere, that we can imagine the reference as a pointer to the vector. So, my question is:
Let's assume that instance of class A, named a, was created with new. We call a.getV() to foo and then we call the destructor of a. foo is safe? Is the copy constructor of std::vector called?
I have in my main(), a function that creates my arg object using boost/program_options.hpp i want to pass this object to another function using templates like this:
Code: template <typename Targ> void Count(Targ & arg){ MyObj<string> QueryTab(arg["input-file"].as<string>()); //line number is 352 ... }
However I get an error:
Code: ../include/Filter.hpp: In member function ‘void Count(Targ&)’: ../include/Filter.hpp:352:40: error: expected primary-expression before ‘>’ token ../include/Filter.hpp:352:42: error: expected primary-expression before ‘)’ token ... obviously it does not recognize my intention, what did I do wrong?
Write a function called breakThree that will accept a 3 digit integer and returns each of the numbers individually. This function will take four paramaters. The first parameter is the three digit number to break apart. Parameters 2 through 4 are passed by reference and will be used to return each of the numbers back to main.
You should make sure that the input into the function is a 3-digit number. If it is not a three digit number the breakThree function should simply return false. If it is a three digit number the breakThree function should break the number apart, and store each of the numbers in the parameters passed by reference.
In main you should get the number from input and then output each of the numbers on a separate line.
What not to use global variables cin in breakThree function cout in breakThree function goto statements
#include <iostream> using namespace std; void separate(int a, int b, int c, int d); int main(int argc, const char * argv[]) { int num;
All entities need to be stored in the dynamic memory. I managed to force this by making the constructor private and by adding a static method which dynamically creates an object and returns a pointer. But it is most likely that the user will want to make them dynamically and we still have the following problem.
entity* player = entity::create(); (*player).setPosition(something); (*player).act(); (*player).draw();
You get the point, having to dereference the pointer before each call becomes painful. So I thought about this... Instead of returning a pointer, I can return a reference. Then the code is much cleaner.
{ entity& test = entity::create();
// do stuff... test.act(); // more stuff...
test.destroy(); // deletes the dynamic object }
I put this code between brackets. That's because we must make sure the reference test doesn't exist after destroy is called, because destroy() makes it invalid. This is fully functional and won't cause any problem as long as the user doesn't forget to never call any method on a destroyed entity. But it's evil code. Would you risk it, or is there another way around?
I'm using GCC 4.8.1 and I want to implement a XML parser using TinyXML and port it to AngelScript
Now, it says: reference to 'Column' is ambiguous
I've declared a class called xml_parser and I've added everything of tinyxml as it's public member when I call Column(), and also Row(), it give's this error. what should I do?
When returning an object by reference, only the address of the returned-object is returned, and that way we spare pushing a large object into the stack, and also spare time of pushing and popping large object to/from stack.
But what happens when the object that receiving the returned-object, is not a reference, but a 'regular' object?
How is the content of the returned object copied into the receiving object?
See for example in main, wid vs rwid. (I know in the case the returned-object is just one variable, there's no need to return it by reference, but its for simplifying the code).
class Rectangle { public: Rectangle(int w=0, int h=0);
#include <iostream> using namespace std; struct A { virtual void f() { cout<<"A "; } };
[code]...
I would expect that both examples 2 & 3 will give me the same result.I tried to figure it out but I could not. Both are references of a base class type, that get a derived object.
Q1 : why is the difference between them ?
As I see it, its kind of a mix between pointer - which in case of virtual method that was override in derived class - would give me the derived method (e.g. "B") and between regular object - which in case of virtual method that was override - would give me the specific method (Still "B"). So, example 2 "use" it as a regular object and example 3, "use" it as pointer.
Q2 : How should I refer to it ? I am using VS2008.
I built a program that finds the average amount of days missed per employee. I am now attempting to modify my program to pass values by reference rather than passing by value. I created 3 functions: int numOfEmployees(); int numOfDays(int); double avgDays(int, int);
in the prototype I use the ampersand sign int numOfDays(int&); in the actual function I use numOfDays(int& employees)
I am just not able to get the call to the function to work the program will crash when I modify it with the ampersand signs.This is the original code I am trying to modify:
#include <iostream> using namespace std; int numOfEmployees(); //Prototype for numOfEmployees int numOfDays(int); //Prototype for numOfDays double avgDays(int, int); //Prototype for avgDays
