C++通过一个数组索引来传递参数/

Question

反正我可以通过类如下面的类传递参数。

class cat 
{public: 
    void dog(int ID, char *value) // int ID I'd like to be the index array it was called from? 
    { 
    debug(ID, value); 
    } 
} 

cat cats[18]; 

cats[1].dog("value second arg, first arg auto filled from index array"); 

Answer 1

我测试了这一点，效果不错：

#include <vector> 

// Forward declaration of the class 
class CatArray; 

class Cat { 
    // This line means that the CatArray class can 
    // access the private members of this class. 
    friend class CatArray; 

    private: 
     static int ID; 

    public: 
     void dog(const char* value) { 
      // Use ID here any way you want. 
     } 
}; 

// Static variables need to be defined. 
int Cat::ID = 0; 

class CatArray { 
    private: 
     std::vector<Cat> cats; 

    public: 
     // explicit means that the argument passed to this constructor must 
     // be an unsigned int. The ": cats(size)" part is an initializer 
     // list that initializes the cats vector so that it would have the 
     // specified size. 
     explicit CatArray(unsigned int size) : cats(size) {} 

     Cat& operator [](unsigned int index) { 
      Cat::ID = index; 
      return cats[index]; 
     } 
}; 

现在这样使用它：

CatArray cats(18); 

cats[1].dog("oh lol hi"); 

此方法适用于任何数量的你想申报阵列。

Answer 2

可以使用静态变量，并增加它在构造函数中，保持所有intances的轨道：

#include<iostream> 


class cat 
{ 
    int ID; 
    static int IDTracker; 
public: 
    cat(); 
    void dog(char* value); 
}; 

int cat::IDTracker = 0; 
cat::cat() 
{ 
    this->ID = cat::IDTracker; 
    cat::IDTracker++; 
} 
void cat::dog(char *value) 
{ 
    std::cout << value << this->ID; 
} 


int main() 
{ 
    cat cats[18]; 
    cats[1].dog("Second instance, with index value: "); 
    cats[2].dog("Third instance, with index vlaue: "); 

    return 0; 
} 

Answer 3

我不能完全肯定这会工作，但它的一些变种可能...

#include <stdio.h> 
#include <stdlib.h> 

void *foo; 

class cat 
{ 
    public: 

    void dog(char *value) // int ID I'd like to be the index array it was called from? 
    { 
    int ID = (this - ((cat *)foo))/(sizeof(cat)); 
    printf("%d - %s",ID, value); 
    } 

}; 


int main (void) 
{ 
    cat cats[18]; 
    foo = &(cats); 
    cats[1].dog("Fido"); 
}