NBN>struct S
NBN>{
NBN>  int* i;
NBN>  S()
NBN>  {
NBN>    i = gcnew int(1);
NBN>  }
NBN>};

NBN>int* f()
NBN>{
NBN>  S s;
NBN>  return s.i;
NBN>}

NBN>int main()
NBN>{
NBN>  int* pi = f();
NBN>}
NBN>

struct S
{
  int i;
};
int* f() // как-то поменять
{
  S* s = gcnew S(); // правильный синтаксис?
  return &s.i; // как-то поменять
}

// в недрах библиотеки
intptr_t getX()
{
    return reinterpret_cast<intptr_t>(new X);
    // ссылки на объект остались, GC его не тронет!
}

// код пользователя
reinterpret_cast<X *>(getX())->doSomething();
// а вот теперь можно и удалить

Goal
• Support
– Conservative Garbage Collection
– Reachability-based leak detection
• Which becomes more critical with quick_exit()
• By
– Giving undefined behavior to programs that hide pointers.
– Providing a small API to “unhide” pointers.
– Providing a small API to make collection less conservative.

R>>Не пользуются ими C++ программисты видимо просто из "исторических" причин. Типа мы же 20 обходились без GC, а теперь Вы нам пытаетесь сказать, что без него нельзя писать работающие программы и жить вообще

void declare_no_pointers( char* p, size_t n ) throw()

Effects:
The n bytes starting at p no longer contain traceable pointer locations, independent of their type. Hence pointers located there may no longer be dereferenced. [Note: This may be used to inform a garbage collector or leak detector that this region of memory need not be traced.]
Throws:
Throws no exceptions. [Note: Under some conditions implementations may need to allocate memory. However the request can be ignored if memory allocation fails. -- end note]
Requires:
No bytes in the specified range may have been previously registered with declare_no_pointers(). If the specified range is in an allocated object, then it must be entirely within a single allocated object. The object must be live until the corresponding undeclare_no_pointers() call. [Note: In a garbage-collecting implementation, the fact that a region in an object is registered with declare_no_pointers() should not prevent the object from being collected. --end note]


void undeclare_no_pointers( char* p, size_t n ) throw()

Effects:
Prepares an object containing a range registered with declare_no_pointers() for destruction. It must be called before the lifetime of the object ends. It has no other effect. It does not recreate any traceable pointer locations in the object.
Requires:
The same range must previously have been passed to declare_no_pointers().

void declare_reachable( void* p ) throw(std::bad_alloc)

Effects:
If p is not null, the complete object referenced by p is subsequently declared reachable (see 3.7.3.3).
Throws:
May throw std::bad_alloc if the system cannot allocate additional memory that may be required to track objects declared reachable.
Requires:
The argument p shall be a safely derived pointer.


template < typename T >
T* undeclare_reachable( T* p ) throw()

Returns:
A safely derived copy of p. The result will compare equal to p.
Effects:
Once the number of calls to undeclare_reachable(p) equals the number of calls to declare_reachable(p) for all non-null p referencing the argument is no longer declared reachable (see [above section]). When this happens, pointers to the object referenced by p may not be subsequently dereferenced unless they are safely derived. [Note: Since the returned pointer is safely derived, it may be used to access the referenced object, even if previously no safely derived pointer existed. -- end note]
Requires:
If p is not null, declare_reachable(p) was previously called, and shall be live from the time of the call until the last undeclare_reachable(p) call on the object.

Не, просто проект нужно делать в нетрадиционном для С++ стиле. А учитывая, что некоторых личностей не уговорить использовать даже SP... Определённые оговорки по использованию GC всётаки есть. Ну и STL не приспособлен к GC

Следуя определенным правилам можно написать программу на языке C++, которая будет работать с использованием SP. Но это будет конкретная программа, а вовсе не факт того, что в C++ появился SP.