• Stan Lippman's BLog

    The String Literal Returns

    • 26 Comments
    In the last entry, I celebrated what I felt was an elegant solution to the problem of the string literal in the context of overload function resolution. But it turns out there is another area in which the string literal proves problematic. Who would have...
  • Stan Lippman's BLog

    The Type of a String Literal Revisited ...

    • 4 Comments
    In the course of these entries, I have twice addressed the issue of the type of a string literal under C++/CLI -- in particular when resolving an overloaded function call. The issue is illustrated in the following example, public ref class R { public...
  • Stan Lippman's BLog

    A Primer on the Interior Pointer

    • 9 Comments
    A value type is typically not subject to garbage collection except in two cases: (a) when it is the subject of a box operation, either explicit or implicit, such as, void f( int ix ) { // explicit placement on the CLI heap int^ result = gcnew int( -1...
  • Stan Lippman's BLog

    Translation Guide between Managed Extensions and the new C++/CLI binding Available

    • 10 Comments
    C and C++ programmers are notorious for relying on pointer indirection, and it seems blog entries are not immune to this. A translation guide attempting to exhaustively detail the differences between the original Managed Extensions for C++ (released with...
  • Stan Lippman's BLog

    An Tour of the STL.NET

    • 12 Comments
    Part of the (reasonably pleasant) distractions from posting on this blog recently has been working up the first in a series of articles on STL.NET for our Visual C++ MSDN web site. The amount of work to get from an articulation of a topic to a formal...
  • Stan Lippman's BLog

    Why C++ Supports both Class and Typename for Type Parameters

    • 6 Comments
    Recently, someone asked me why we support both class and typename within C++ to indicate a type parameter since the keywords do not hold any platform significance – for example, class is not meant to suggest a native type nor is typename meant to suggest...
  • Stan Lippman's BLog

    Why C++/CLI Supports both Templates for CLI Types and the CLI Generic Mechanism

    • 16 Comments
    I've been recently puzzling out a strategy for presenting the two mechanisms supporting parameterized types available to the C++/CLI programmer: she can use either the template mechanism adapted for use with CLI types, or the CLI generic mechanism. This...
  • Stan Lippman's BLog

    Identifying the Candidate Function Set

    • 6 Comments
    Sorry it is taking me so long these days. I am in the throes of more formal writing – a book on our CLI binding for C++, and a series of articles for our Visual C++ MSDN website on STL.NET. And my translation tool is happily going through a formal...
  • Stan Lippman's BLog

    The Value of a Value Class

    • 9 Comments
    A reader questions the nature of the value type when he writes, Sender: Slawomir Lisznianski ===================================== 1) Lack of support for SMFs makes value classes unnatural to use. An example in the C++/CLI spec at page 33 is incorrect...
  • Stan Lippman's BLog

    String Literal Conversion to String: Is It a Disaster?

    • 1 Comments
    A reader asks, Sender: Jack re: String Literals are now a Trivial Conversion to String Won't it break most of existing libraries who will try to port to C++/CLI? One override for String^ will break a lot of user code and make calls for the overriden...
  • Stan Lippman's BLog

    String Literal Conversion to String: Is It a Disaster?

    • 0 Comments
    A reader asks, Sender: Jack re: String Literals are now a Trivial Conversion to String Won't it break most of existing libraries who will try to port to C++/CLI? One override for String^ will break a lot of user code and make calls for the overriden...
  • Stan Lippman's BLog

    String Literals are now a Trivial Conversion to String

    • 6 Comments
    There was a recent internal thread on the resolution of the following set of overloaded member functions of a reference class R. It represents a change in the earlier definition of C++/CLI, and a difference in type behavior that I reported in an earlier...
  • Stan Lippman's BLog

    Factor, Don't Complicate

    • 7 Comments
    A reader asks the following question, Sender: bv re: A Question about Copy Constructors in C++/CLI Ok, i have a question. What happens if: suppose you want to make a shallow copy. Ex: ClassX obj(somePtr);//internally obj.m_ptr...
  • Stan Lippman's BLog

    Putting C++ and the CLI in Perspective

    • 6 Comments
    A surprising thread that has emerged has to do with libraries. Here is an representative example, Sender: Dobes ===================================== re: Towards a Natural Theory of Programming Languages I also think that the survival...
  • Stan Lippman's BLog

    System::String -> std::string

    • 8 Comments
    A reader asks, Sender: Erik Brendengen Is there an easy way to convert from String^ to std::string? Does String ^s = std::string( “bla”).c_str(); work the other way? This is a FAQ, one that I myself bumped into when I...
  • Stan Lippman's BLog

    A Question of Interopt

    • 1 Comments
    A reader asks the following question, Sender: Richard Hsu Stan, Would you suggest, for those of us who are yet to begin learning MC++, to wait till C++/CLI ships, because we'll not only be learning what will be obsolete syntax, but also...
  • Stan Lippman's BLog

    A Reader Bleakly Asks About the Future of C++ within Microsoft

    • 13 Comments
    A reader writes Sender: Brian Braatz ===================================== I posted the following to the boost email group and receieved the following response. I was wondering if you had any comments or thoughts on this. I am personally concerned...
  • Stan Lippman's BLog

    C++/CLI: System::String^, std::string, and "a string literal"

    • 5 Comments
    Without thinking too hard I had held the following precept: std::string is to ISO C++ as System::String^ is to C++/CLI. Or, to give the idea a political tint, I thought of the two string abstractions as separate but equal library class types. Therefore...
  • Stan Lippman's BLog

    Yes, Value Types Have No Destructors

    • 4 Comments
    A reader comments Sender: Joe Pacheco ===================================== re: Integrating Dispose and Finalize into the Language What about destructors for value classes? Was it considered when you did the language design? ...
  • Stan Lippman's BLog

    Integrating Dispose and Finalize into the Language

    • 4 Comments
    A reader comments re: Changes in Destructor Semantics in Support of Deterministic Finalization I agree with Johan. I use a pattern where all classes that need a finalizer must implement the Dispose pattern, and all classes with a Dipose...
  • Stan Lippman's BLog

    Changes in Destructor Semantics in Support of Deterministic Finalization

    • 16 Comments
    In the original language design, a class destructor was permitted within a reference class but not within a value class. This has not changed in the revised V2 language design. However, the semantics of the class destructor have changed considerably....
  • Stan Lippman's BLog

    Having the right Type Vocabulary to discuss Boxed Value Types

    • 3 Comments
    Comments from Stan Lippman's BLog: Jon Flanders re: Value Type Redux I think it is always important to point out when having the “value types are boxed whenever they are treated as object” discussion, that if the value type overrides ToString...
  • Stan Lippman's BLog

    Value Type Redux

    • 2 Comments
    I’d like to thank Yves Dolce for responding to Wesner Moise who writes: Sender: Wesner Moise re: Value Type Representation Between the Original and Revised C++ I am not sure that I understand you when you say v.ToString() results...
  • Stan Lippman's BLog

    Value Type Representation Between the Original and Revised C++

    • 11 Comments
    For the work I’ve been engaged in currently in machine translation of the original language design [thing1] to the revised design of the language [thing2], I have been variously making stabs at understanding the possible usages of a managed Value...
  • Stan Lippman's BLog

    Some Thoughts on Program Efficiency

    • 10 Comments
    Program efficiency at the programmer level is something of a complicated issue – in part because it is contextual. That is, it is hard to say something that holds true in all cases. [This is why having a good profiler is essential.] For example...
Page 1 of 3 (55 items) 123