typedef struct {
 double x;
 double y;
} Pnt;

int main(void){
  Pnt *PntPtr;

  with Pnt{
    x=1;
    y=2;
  }
}

instead of

typedef struct {
 double x;
 double y;
} Pnt;

int main(void){
  Pnt *PntPtr;

  PntPtr->x=1;
  PntPtr->y=2;
  }
}

struct foo {
 double x, y;
};

foo* get_foo() { /* expensive, don't call multiple times */ }

int main(){
  {
    foo& a = *get_foo(); // local scope justifies short identifier
    a.x=1;
    a.y=2;
  }
}

is probably the best approximation.

class Point
{
  double x, y;
public:
  Point(double x, double y): x(x), y(y) {}
  void setxy(double xx, double yy) { x = xx; y = yy; }
  friend std::ostream& operator<< (std::ostream& out, const Point& point)
  {
     return out << point.x << '\t' << point.y;
  }
};

void change(Point &point)
{
  point.setxy(6,7);
}

int main()
{
  Point p(1,2);
  std::cout << p << '\n';
  change(p);
  std::cout << p << '\n';
}

Therefore it seems it is the best way either to use all references or all pointers, dependent if you write a cpp module for c or cpp itself.

#include <iostream>
#include <ctime>

using namespace std;

struct Point_t {double x,y,z;};

double distance1(Point_t* p){
  return p->x*p->x + p->y*p->y + p->z*p->z;
}

double distance2(Point_t* p){
  Point_t &q = *p;
  return q.x*q.x + q.y*q.y + q.z*q.z;
}

double distance3(Point_t &p){
  return p.x*p.x + p.y*p.y + p.z*p.z;
}

int main(void){
  Point_t p = {1,2,3};
  clock_t c;

  c = clock();
  cout << "Testing Struct Access with dereferencing" << endl;

  for (long long int i = 0; i < 1000000000; i++){
    //cout << distance1(&p) <<'\t';
    distance1(&p);
  }
  cout << "clocks needed:" << (clock()-c)/(CLOCKS_PER_SEC) << endl;

  c = clock();
  cout << endl << "Testing Struct Access, converting pointer to reference" << endl;

  for (long long int i = 0; i < 1000000000; i++){
    //cout << distance2(&p) << '\t';
    distance2(&p);
  }
  cout << "clocks needed:" << (clock()-c)/(CLOCKS_PER_SEC) << endl;

  c = clock();
  cout << endl << "Testing Struct Access, only reference used" << endl;

  for (long long int i = 0; i < 1000000000; i++){
    //cout << distance2(&p) << '\t';
    distance3(p);
  }
  cout << "clocks needed:" << (clock()-c)/(CLOCKS_PER_SEC) << endl;

}

If you look at the generated assembler code, you will notice that it's the same in all three cases.

Ok, made a small test program comparing the different methods.
Seems, in speed there is not much difference (about 10%), compiled with gcc and running on a win7 intel machine.

Actually, there should be absolutely no difference at all. Did you activate optimization? Probably not, as the GCC is a rather aggressive optimizer and would have completely removed all the loops as they do not actually do anything.

Actually, there should be absolutely no difference at all. Did you activate optimization? Probably not, as the GCC is a rather aggressive optimizer and would have completely removed all the loops as they do not actually do anything.

Yep, it doesn't make any difference: http://gcc.godbolt.org/#{"version"%3A3%2C"filterAsm"%3A{"labels"%3Atrue%2C"directives"%3Atrue%2C"commentOnly"%3Atrue%2C"intel"%3Atrue}%2C"compilers"%3A[{"source"%3A"struct Point_t {double x%2Cy%2Cz%3B}%3B \n\ndouble distance1(Point_t* p){ \n return p->x*p->x %2B p->y*p->y %2B p->z*p->z%3B \n} \n \ndouble distance2(Point_t* p){ \n Point_t %26q %3D *p%3B \n return q.x*q.x %2B q.y*q.y %2B q.z*q.z%3B \n} \n \ndouble distance3(Point_t %26p){ \n return p.x*p.x %2B p.y*p.y %2B p.z*p.z%3B \n} \n"%2C"compiler"%3A"%2Fusr%2Fbin%2Fg%2B%2B-4.8"%2C"options"%3A"-O3 -std%3Dc%2B%2B11"}]}