Trouble finding size of pointer array passed to function

[oldspiderdude]

Hi, I'd like to get the size of the pointer array passed to the function.
(On line 20)

arrSize=sizeof(inputArr)/sizeof(inputArr[0]) ;

did not work.
On line 20, if I use

arrSize=std::array::size(inputArr);

it will say
"print n of n back\main.cpp|20|error: 'template<class _Tp, unsigned int _Nm> struct std::array' used without template parameters|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|"

but if I write

arrSize=size(inputArr);

it says size is not declared

here is my entire code

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <array>
using namespace std;

template <class T, size_t N> class array;

struct node{
int value;
int n;
node* next;
};
void printN(node *inputArr[],int m) {
    // cout << "I'm in" << endl;
    int numRep=inputArr[m-1]->n;
    // cout << "I'm in 2" << endl;
    int refPos=m-1;
    // cout << "I'm in 3" << endl;
    int arrSize=std::array::size(inputArr);
    // cout << "I'm in 4" << endl;
    cout << "refPos, numRep, arrSize: " << refPos << " " << numRep <<
    " " << arrSize << endl;
    // cout << sizeof(node) << endl;
    refPos=refPos-(numRep%arrSize);
    // cout << "I'm in 5" << endl;
    if (refPos<0) {
        refPos=refPos+arrSize;
        // cout << "I'm in 6" << endl;
    }

    numRep==1 ?
    cout << "The value of n at "<< numRep <<
    " block before m=" << m << " is: " << inputArr[refPos]->n << endl:
    cout << "The value of n at "<< numRep <<
    " blocks before m=" << m << " is: " << inputArr[refPos]->n << endl;
    return;
}


int sizeArr, maxN, input;

int main()
{   cin >> sizeArr >> maxN;
    srand (time(NULL));
    node *head=NULL,*last=NULL;
    node *arr[sizeArr];
    for (int createNode=0; createNode<sizeArr ;createNode++) {
        arr[createNode]=(node*)malloc(sizeof(node));
        if (head==NULL) {
            head=arr[createNode];
        }
        arr[createNode]->value=createNode+1;
        arr[createNode]->n=rand()%(maxN+1);
        if (last!=NULL) {
            last->next=arr[createNode];
        }
        last=arr[createNode];
    }
    arr[sizeArr-1]->next=head;
    for (int loop=0; loop<sizeArr;loop++) {
        cout << arr[loop]->value << "\t" << arr[loop]->n << endl;
    }
    cout << endl;
    while (1) {
        cin >> input;
        if (input==0) {return 0;}
        printN(arr,input);
    }

    return 0;
}

[gunnerfunner]

try inputArr.size()
http://en.cppreference.com/w/cpp/container/array/size

[oldspiderdude]

I did, it didn't work

"
print n of n back\main.cpp|19|error: request for member 'size' in 'inputArr', which is of non-class type 'node**'|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===| "

[alonso12]

I think you'll have to pass the size as a parameter.
void printN(node *inputArr[], int m, int size) {

[Enoizat]

#include <array>
...
template <class T, size_t N> class array;
...
int arrSize=std::array::size(inputArr);

Are you re-defining std::array? What are you trying to achieve? You are mixing C and C++ headers and programming styles together. Could you please describe what your code should do?

[oldspiderdude]

I want to create an array of pointers, and find its size in a function without passing its size to the function (only pass the array of pointers to the function)

#include <array>

struct node*{
int value;
node* next;
}

void someFunc (node* arr[], int irrelevant) {
int arrSize= ... // I need to find the size of the array here
}

int inputArrSize, someNumber=0;

int main() {
cin >> inputArrSize;
...
node (*arr)[inputArrSize];
...
someFunc (arr,someNumber)

return 0;
}

[Enoizat]

std::array<node*, inputArrSize> my_std_array_of_pointer;

A std::array knows its size, so you don't need to pass that information:
my_std_array_of_pointer.size();

gunnerfunner has already given you a link for further references.

[Cubbi]

oldspiderdude wrote:

I want to create an array of pointers, and find its size in a function without passing its size to the function (only pass the array of pointers to the function

size of any array (both T[N] and array<T,N>) is known at compile time, so your function has to be a template in order to be callable with arrays of different size

#include <array>
#include <iostream>
struct node{ int value; node* next; };
template<size_t N>
void someFunc(node*(&arr)[N]) { std::cout << "size: " << N << '\n'; }
template<size_t N>
void someFunc(std::array<node*, N>& arr) { std::cout << "size: " << N << '\n'; }
int main() {
  node* a[10];
  std::array<node*, 10> b;
  someFunc(a);
  someFunc(b);
}

live demo: https://wandbox.org/permlink/kPNqsceJ4WSJ3EU5

oldspiderdude wrote:

void someFunc (node* arr[], int irrelevant)

This function does not take an array. It's the old C bug/feature/hack for backwards compatibility with B that arrays cannot be used as function parameters, but instead of making that an error, the C compiler quietly replaces that function declaration with one taking a pointer - the function you declared is really void someFunc (node** arr, int irrelevant), arrays are not involved in any way.

cin >> inputArrSize;
node (*arr)[inputArrSize];

Even if you fix that to create an array of pointers (currently it creates a pointer to an array) this is invalid: inputArrSize is not a constant and you cannot declare an array of non-constant size in C++. If you're using a compiler that allows that, fix it by using commandline option -pedantic-errors

If your size is not known until runtime, use std::vector<node*>