• 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

    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

    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

    Implicit Boxing

    • 14 Comments
    What s Different in the Revised Language Definition? Implicit Boxing     Ok, so we reversed ourselves. In politics, that would likely loose us an election. In language design, it means that we imposed a...
  • 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

    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

    The Revised C++ Language Design Supporting .NET -- Part 1

    • 11 Comments
    Probably the most conspicuous and eyebrow-lifting change between the original and revised design of the dynamic programming support within C++ is the change in the declaration of a .NET reference type:   // original language...
  • 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...
  • 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

    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

    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

    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

    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

    A Fundamental Difference in Class Behavior between the Native and Managed Object Model

    • 7 Comments
    I have used two primary metaphors in my discussions of bring C++ to the .NET platform. In terms of the different physics of the two object models, I have distinguished them as Kansas and Oz, and claimed with little apparent success that the physics of...
  • Stan Lippman's BLog

    Property Declarations

    • 7 Comments
    What s Different in the Revised Language Definition? Declaring Properties In the original language design, each set or get property accessor is specified as an independent member function. The declaration of each method is...
  • Stan Lippman's BLog

    Further Discussion of MI and general C++/CLI design issues

    • 7 Comments
    That same reader from the previous two posting responds as follows, with some editing. I am responding only because it gives me an excuse to speak of technical implementation issues, which I enjoy, and which readers often find interesting. With regard...
  • Stan Lippman's BLog

    Followup: The Absence of MI

    • 6 Comments
    That same reader from the previous posting now writes the following, where he quotes me and then makes his comment [this is great, by the way. this is much more engaging than the technical writing]: “There are some significant implementation...
  • Stan Lippman's BLog

    The Revised C++ Language Design - Part 2

    • 6 Comments
    The Revised C++ Language Design Supporting .NET -- Part 2 The fundamental design choice in supporting the .NET reference type within C++ is to decide whether to remain within the existing language, or to extend the language, thereby breaking...
  • Stan Lippman's BLog

    Finishing the Hat

    • 6 Comments
        Finishing the Hat (^) Once it became clear that support for .NET within C++ represented a distinct programming paradigm, it followed that the language needed to be extended to provide both a first class coding...
  • Stan Lippman's BLog

    A Question of Const

    • 6 Comments
    A reader, J. Daniel Smith , inquiries You wrote “The absence of const support in the base class library… “; Can you elaborate any on what the plans are for “const” as they relate to C++/CLI and C#? I...
  • Stan Lippman's BLog

    The Name Return Value Optimization

    • 6 Comments
    I received the following mail the other day in response to my writing that the Visual C++ compiler has [finally!] implemented the name return value optimization (NRVO) in the Visual Studio 2003 release: Sender: James Slaughter I was in the...
  • 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

    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

    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...
Page 1 of 3 (55 items) 123