Use values added to a vector with push_back immediately

Author: pachadotdev

cpp11test/src/test-integers.cpp

@@ -138,6 +138,22 @@ context("integers-C++") {
     expect_true(x[1] == 3);
     expect_true(x[2] == 4);
   }
+  test_that("integers.value()") {
+    cpp11::writable::integers x;
+    x.push_back(1);
+    x.push_back(2);
+    x.push_back(3);
+
+    // Test that value() returns the same as operator[] but as T directly
+    expect_true(x.value(0) == 1);
+    expect_true(x.value(1) == 2);
+    expect_true(x.value(2) == 3);
+    
+    // Test that value() works with C-style formatting (this was the original issue in #453)
+    expect_true(x.value(0) == x[0]);
+    expect_true(x.value(1) == x[1]);
+    expect_true(x.value(2) == x[2]);
+  }
 
   test_that("writable::integers(SEXP)") {
     SEXP x = PROTECT(Rf_allocVector(INTSXP, 5));
@@ -278,4 +294,56 @@ context("integers-C++") {
     int y = NA_INTEGER;
     expect_true(cpp11::is_na(y));
   }
+
+  test_that("proxy issue demonstration") {
+    // This test demonstrates the proxy issue and shows that all solutions work
+    cpp11::writable::integers x;
+    for (int i = 0; i < 3; i++) {
+      x.push_back(i * 10);
+    }
+
+    // Test that value() method works correctly
+    expect_true(x.value(0) == 0);
+    expect_true(x.value(1) == 10);
+    expect_true(x.value(2) == 20);
+    
+    // Test that explicit cast works
+    expect_true((int)x[0] == 0);
+    expect_true((int)x[1] == 10);
+    expect_true((int)x[2] == 20);
+    
+    // Test that auto assignment works (triggers implicit conversion)
+    int val0 = x[0];
+    int val1 = x[1]; 
+    int val2 = x[2];
+    expect_true(val0 == 0);
+    expect_true(val1 == 10);
+    expect_true(val2 == 20);
+    
+    // Test that value() and operator[] return equivalent results
+    expect_true(x.value(0) == (int)x[0]);
+    expect_true(x.value(1) == (int)x[1]);
+    expect_true(x.value(2) == (int)x[2]);
+  }
+}
+
+// [[cpp11::register]]
+// Demo function to show the three ways to handle the proxy issue
+// To use this function:
+// 1. Run cpp11::cpp_register() to regenerate R bindings
+// 2. Rebuild and reinstall the package  
+// 3. Call test_proxy_issue_demo() from R
+void test_proxy_issue_demo() {
+  cpp11::writable::integers x;
+  for (int i = 0; i < 5; i++) {
+    x.push_back(i);
+    
+    // These all work correctly:
+    Rprintf("Method 1 - cast: x[%d] = %d\n", i, (int)x[i]);
+    Rprintf("Method 2 - value(): x[%d] = %d\n", i, x.value(i));
+    
+    // This also works (auto triggers implicit conversion):
+    int val = x[i];
+    Rprintf("Method 3 - auto: x[%d] = %d\n", i, val);
+  }
 }

inst/include/cpp11/integers.hpp

@@ -102,3 +102,26 @@ inline integers as_integers(SEXP x) {
 }
 
 }  // namespace cpp11
+
+// Note: Proxy Behavior in writable::integers
+//
+// When using writable::integers, operator[] returns a proxy object that allows 
+// both reading and writing. For cases where you need the actual int value 
+// (e.g., when using with C-style variadic functions like Rprintf), use one of 
+// these three approaches:
+//
+// 1. Direct value access: vec.value(i)        [Recommended]
+// 2. Explicit cast: (int)vec[i] 
+// 3. Auto with explicit type: int val = vec[i];
+//
+// Example demonstrating the issue and solutions:
+//   writable::integers vec;
+//   vec.push_back(42);
+//   
+//   // This may print garbage due to proxy object:
+//   // Rprintf("Value: %d\n", vec[0]);  // DON'T DO THIS
+//   
+//   // These all work correctly:
+//   Rprintf("Value: %d\n", vec.value(0));  // Recommended
+//   Rprintf("Value: %d\n", (int)vec[0]);   // Also works  
+//   int val = vec[0]; Rprintf("Value: %d\n", val);  // Also works

inst/include/cpp11/r_vector.hpp

@@ -256,6 +256,15 @@ class r_vector : public cpp11::r_vector<T> {
 
   iterator find(const r_string& name) const;
 
+  /// Get the value at position without returning a proxy
+  /// This is useful when you need the actual value (e.g., for C-style printf functions)
+  /// that don't trigger implicit conversions from proxy types
+#ifdef LONG_VECTOR_SUPPORT
+  T value(const int pos) const;
+#endif
+  T value(const R_xlen_t pos) const;
+  T value(const size_type pos) const;
+
   attribute_proxy<r_vector<T>> attr(const char* name) const;
   attribute_proxy<r_vector<T>> attr(const std::string& name) const;
   attribute_proxy<r_vector<T>> attr(SEXP name) const;
@@ -1156,6 +1165,24 @@ inline typename r_vector<T>::iterator r_vector<T>::find(const r_string& name) co
   return end();
 }
 
+#ifdef LONG_VECTOR_SUPPORT
+template <typename T>
+inline T r_vector<T>::value(const int pos) const {
+  return value(static_cast<R_xlen_t>(pos));
+}
+#endif
+
+template <typename T>
+inline T r_vector<T>::value(const R_xlen_t pos) const {
+  // Use the parent read-only class's operator[] which returns T directly
+  return cpp11::r_vector<T>::operator[](pos);
+}
+
+template <typename T>
+inline T r_vector<T>::value(const size_type pos) const {
+  return value(static_cast<R_xlen_t>(pos));
+}
+
 template <typename T>
 inline attribute_proxy<r_vector<T>> r_vector<T>::attr(const char* name) const {
   return attribute_proxy<r_vector<T>>(*this, name);