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"); 
}