retrieving a specific value from sctruct c++

Question

So I have a struct, and there I would like to access specific values from within it in another method. I am not allowed to modify the struct itself. Here is the struct and a couple of functions that are used to initialize and access it.

struct StdCardConfirmationReceipt
{
private:
    std::string sOfrIdOrderCentral;
    std::string sOrderIdOrderCentral;
    std::string sFulfillmentOrderIdOrderCentral;

public:
    StdCardConfirmationReceipt()
    {       
        sOfrIdOrderCentral = "";
        sOrderIdOrderCentral = "";
        sFulfillmentOrderIdOrderCentral = "";
    }

    StdCardConfirmationReceipt& operator=(const StdCardConfirmationReceipt& source )
    {
        sOfrIdOrderCentral                  = source.sOfrIdOrderCentral;
        sOrderIdOrderCentral                = source.sOrderIdOrderCentral;
        sFulfillmentOrderIdOrderCentral     = source.sFulfillmentOrderIdOrderCentral;
    }

I would like to get these values 'sOFrIDOrderCentral' and sFulfillmentOrdIdOrderCentral' and put it in another struct. Is this possible with the above code? Here is the for-loop I'm using in the other method to access the struct.

for(std::vector<StdCardConfirmationReceipt>::iterator vIter= mvCardConfirmationReceiptList.begin(); vIter != mvCardConfirmationReceiptList.end(); ++vIter)
{
    //need to accesss OFrIDOrderCentral and sFulfillmentOrdIdOrderCentral
}

Answer 1

http://bloglitb.blogspot.com/2010/07/access-to-private-members-thats-easy.html

Essentially you're asking for access to private members. To quote the full source of the link to ensure it doesn't go stale:

#include <iostream>
using namespace std;

template<typename Tag>
struct result {
  /* export it ... */
  typedef typename Tag::type type;
  static type ptr;
};

template<typename Tag>
typename result<Tag>::type result<Tag>::ptr;

template<typename Tag, typename Tag::type p>
struct rob : result<Tag> {
  /* fill it ... */
  struct filler {
    filler() { result<Tag>::ptr = p; }
  };
  static filler filler_obj;
};

template<typename Tag, typename Tag::type p>
typename rob<Tag, p>::filler rob<Tag, p>::filler_obj;

struct A {
private:
  void f() {
    std::cout << "proof!" << std::endl;
  }
};

struct Af { typedef void(A::*type)(); };
template class rob<Af, &A::f>;

int main() {
  A a;
  (a.*result<Af>::ptr)();
}

Essentially using this method would achieve what you want. You should not be doing this, however. It breaks encapsulation and creates exceptionally brittle code.

This can cause incredible maintenance headaches and is generally terrible programming practice. The reason your answer has gotten so many downvotes is because it promotes terrible code if you subvert the information hiding mechanisms built into the language.

Answer 2

Unfortunately, all of those members are private, so they cannot be accessed from outside of the class. You'll need to either write accessor functions:

#include <vector>
#include <iostream>

struct StdCardConfirmationReceipt {
private:
    std::string sOfrIdOrderCentral;
public:
    StdCardConfirmationReceipt() : sOfrIdOrderCentral() {}
    StdCardConfirmationReceipt(std::string s) : sOfrIdOrderCentral(s) {}
public:
    const std::string& getsOfrIdOrderCentral() const { return sOfrIdOrderCentral; }
};

int main() {
    std::vector<StdCardConfirmationReceipt> vec;
    vec.push_back(StdCardConfirmationReceipt("1"));
    vec.push_back(StdCardConfirmationReceipt("2"));
    vec.push_back(StdCardConfirmationReceipt("3"));
    for (auto vIter = vec.begin(); vIter != vec.end(); ++vIter) {
        std::cout << vIter->getsOfrIdOrderCentral();
    }
}

http://ideone.com/kdwyWL

Answer 3

If you have a struct with private data members that you want to access, you can always #define private public right before the struct definition and access them as normal. If you can, just use accessor functions as this is extremely bad practice.