C/C++ Inputting an array in to a function or returning an array? (C++)

[Zurtex]

I recently came up with a bit of a mathematical problem for myself and decided I needed a bit of code to help me. My understanding of C++ is pretty basic and I seem to have found myself stuck mixing arrays and functions.

I wrote the function:

int worko (int c[], int tri)
{
    //turns the array into the number it represents
    int ans = 0;
    int i;
    for (i=0; i < tri; i++)
    {
        ans = ans + 2^c[i]*(i+1);
    }
    return ans;    
}

But in my main() the line:

int test = worko(poss[],tri);

Where poss[] is an array of length tri and tri is some integer, returns the compiler error:

68 C:\Documents and Settings\Administrator\My Documents\sillyproblem.cpp expected primary-expression before ']' token

Any ideas?

Also I want to write a function which goes something like:

int addone[] (int d[], int tri, int log)
{
    d[0] = d[0]+1;
        int j;
        for (j=0; j < tri; j++)
        {
            if (d[i] > log)
            {
                d[j]=0;
                d[j+1]++;
            }
        }
return d[];
}

But C++ seems to have no concept of returning arrays, any idea what I need to be looking at to get around this? Thanks for any help at all.

 

[Hurkyl]

You almost surely want to be using std::vector instead of ordinary arrays.


But if you insist on using ordinary arrays, then they cannot be passed as a return value -- you have to pass them as arguments to your function 'by reference', so the function can modify them in place.

Also, you seem to misunderstand the syntax of ordinary arrays. [] is a decoration used to describe the type when declaring a variable: it is not part of the name of the variable.


By the way, I'm not sure exactly what the first function is supposed to be doing... but allow me to remind you that ^ is not exponentiation: it is bitwise exclusive-or.

 

[Zurtex]

Thanks! I've not programed in C++ in about 2 years. I did forget about ^ (goes and looks up what the exponential is).

I have absolutely no insistence in using standard arrays, I'll go and look up whatever "std::vector" is .



P.S The idea of the first function is that it takes the array [x₁,...,x_n] and calculates the value 1*2^x₁ + 2*2^x₂ + ... + n*2^x_n.

I'm trying to work out the set of integers which can't be represented in that form, where {x_i}_{i = 1,...,n} is a monotonically decreasing sequence of non-negative integers. For example, 5 and 11 can't be represented in that form, I have a good idea which numbers in general can't be represented in that form but I wanted to quickly write something into the computer to confirm my idea for a few more integers.

 

[signerror]

Look up C-style arrays and pointers. I recommend the chapter in

The C Programming Langauge has often been cited as a model for technical writing, due to the book's clear presentation and concise treatment.

You will trip up often working with C-style arrays (what you are using) until you actually understand what they really represent. They are not atomic vectors, things you can pass around as a unit or assign values to. They are regions of memory space, in which their contents are stored. They are intimately connected with the memory pointer, which has how you reference memory in C and C++. What you pass around when you manipulate arrays is not a vector or a set, but a memory pointer.

This is not easy or intuitive, because C and C++ are "low level" languages - they are designed for system programming that closely reflects the HARDWARE, not like "high level" languages, which use natural concepts suitable for HUMANS. You will probably find things much easier in a high level language like Python, where lists (superficially like arrays) are first-class objects, which you can directly return from functions and so on. Also, the syntax is much more straightforward, and you can program interactively in an interpreter.

(recommended!)

If you stick with C++, an alternative is what Hurkyl mentioned, the standard template library containers (STL = standard template library), which attempts to bring abstractions like vectors (std::vector) and lists to C++. But you certainly find things easier in Python.

I did forget about ^ (goes and looks up what the exponential is).

In C++, you will need to include something like <cmath> which has as exp() function. Python for contrast has a built-in exponentiation operator (it is **).

 

[signerror]

As a preview: in C++, to write a function which takes an array, and returns the array scaled by a constant factor, the type signature would look like:

float* scale(float scalefactor, float arr[], int length);

Where float* is a pointer type. And the implementation would look like:

float* scale(float scalefactor, float arr[], int length) {
   float* ans = new float[length];
   for (int i = 0; i < length; i++) {
      ans[i] = scalefactor * arr[i];
   }

   return ans;
}

where 'new' is how you can dynamically create an array of variable size - it is manual memory allocation. And you could use it like:

float arr[] = {1,2,3};
float* ans = scale(10, arr, 3);
std::cout << ans[0] << " " << ans[1] << " " << ans[2] << "\n";
// prints "10 20 30"

Note that the function calling convention for an array or pointer argument does not include either the '[]' or '*' - those are for type declarations (and other stuff). This:

float* ans = scale(10, arr, 3);

Not this:

float* ans = scale(10, arr[], 3);

C++ is byzantine, and this isn't even the start of it.

 

[Potential]

I usually pass arrays around with pointers...just make sure they are in sequential memory addresses when allocating the memory like so:

const int nTri = 6;
int rgC[nTri] = { 0 };
int nRes = worko(rgC, nTri);