Вопрос:Чем похожи женщина-математик и морская свинка.
Ответ:И та и другая не является ни тем ни другим.

   void foo(int count)
   {
     HungryForResources resource_waster (count);
     resource_waster.eatAsMuchAsYouNeed();
   }

   void foo(int count)
   {
     using (HungryForResources resource_waster = new HungryForResources (count))
     {
       resource_waster.eatAsMuchAsYouNeed();
     }
   }

int i = 10;

int^ i_boxed = i;

// Далее можно использовать "забоксенное" значение i без повторного боксинга.
. . .

// Можно даже получить прямую ссылку на целое, лежащее в боксе:

int% i_ref = %i_boxed;

At the PDC, I was asked whether C# thinks they’re in the middle. The answer is absolutely! A few years ago, the usability team at Microsoft developed personas for programmers in each of the languages. The Visual Basic developer was the “opportunistic programmer”, the C# developer was the “pragmatic programmer”, and the C++ developer was kind of guy who knew the whole system.

Yes, managed code is the direction we are going in moving forward for all the places where it makes sense. However extrapolating that to mean C# is simply not true. We are spending a lot of resources to make sure C++ is a primary development language on the .Net platform and are seeing a lot of internal adoption of C++ to write managed code inside of Microsoft. In the RTM version the primary focus of MC++ is to enable you take integrate easily with existing code, but in future releases you will see us focusing much more on making C++ take up the traditional role it serves role as the high end language for system level programming and for expert level programming on the .Net platform.

In VS 2005, C++ is the systems programming language for .NET. If you already know C++, there is no need to use another language, although you're free to use whatever language you like for all or any part of your application. C++ is not the simplest .NET language, just the most powerful one that exposes the most .NET CLR features and that usually generates the best optimized IL.

C++ gives the programmer unprecedented flexibility to write high-performance managed code, and it does it all in a way that is natural to C++ programmers. There are many languages available for .NET-enabled programming; if you care about maximum performance, Visual C++ is the obvious choice.

Well, for one C++ developers are really multilingual developers. They use the programming language best suited for a task. A C++ programmer also tends to understand the whole system, and doesn’t mind reading MSIL or assembly code. C++ developers also think in much broader contexts – they think about the architecture of the whole program, rather than just single pieces. C++ developers also tend to appreciate lower level components that can be combined to create simpler components. (It’s really very difficult to create components with more utility from higher level components that have less utility). C++ programmers tend to think about performance more often, and understand the dependencies in their programs. C++ programmers try to maximize tools available to get things done more efficiently (be it, sed, awk, profilers, lint tools, perl scripts, etc.) C++ programmers will also build tools to get the job done when a tool is not available.

At the PDC, I was asked whether C# thinks they’re in the middle. The answer is absolutely! A few years ago, the usability team at Microsoft developed personas for programmers in each of the languages. The Visual Basic developer was the “opportunistic programmer”, the C# developer was the “pragmatic programmer”, and the C++ developer was kind of guy who knew the whole system.

Visual C# .NET 2003 is the comprehensive tool set for creating XML Web services and Microsoft .NET-connected applications for Windows and the Web using the component-oriented C# development language. View product information, including case studies, news and reviews, and system requirements. Plus, get information on how to obtain this robust development package offering beginning and intermediate developers with C++ or Java experience a modern language and environment for creating next-generation software.

Container<MyStruct> vec;
vec.Add(new MyStruct(10, 20));
vec[0].X += 1;

generic<class T>
class Container
{
public:
   . . .
   T% operator[](int index);
   . . .
};

1 day to port the entire Quake 2 source base. (Nearly all of to port the entire Quake 2 source base. (Nearly all of the effort was to translate from C to C++, and had nothing to do with our compiler or the .NET platform.)

ПК>Container<MyStruct> vec;
ПК>vec.Add(new MyStruct(10, 20));
ПК>vec[0].X += 1;
ПК>

ПК>generic<class T>
ПК>class Container
ПК>{
ПК>public:
ПК>   . . .
ПК>   T% operator[](int index);
ПК>   . . .
ПК>};
ПК>

deledate void Modify(ref T elem);

void ModifyAt(Modify modify, int index)
{
    modify(ref _internalArray[index]);
}

> ПК>generic<class T>
> ПК>class Container
> ПК>{
> ПК>public:
> ПК>   . . .
> ПК>   T% operator[](int index);
> ПК>   . . .
> ПК>};
> ПК>

public T this[ int index ] {get; set;}

property T% default[int] {
   T% get(int index) { . . . }
   void set(T% value, int index) { . . . }
}

> deledate void Modify(ref T elem);
>
> void ModifyAt(Modify modify, int index)
> {
>     modify(ref _internalArray[index]);
> }
>

ПК>Дык, речь-то идет о том, для кого проектировался язык

What makes C# and C++ programmers different?

At the PDC, I was asked whether C# thinks they’re in the middle. The answer is absolutely! A few years ago, the usability team at Microsoft developed personas for programmers in each of the languages. The Visual Basic developer was <...>

class A< T > : where T : struct { ... }

ПК>public T this[ int index ] {get; set;}
ПК>

ПК>property T% default[int] {
ПК>   T% get(int index) { . . . }
ПК>   void set(T% value, int index) { . . . }
ПК>}
ПК>

    unsafe class A
    { 
        int[] _array = new int[10];

        public int* this[int i]
        {
            get 
            {
                fixed (int * p = &_array[i])
                    return p;
            }
        }
    }

    class Program
    {
        unsafe static void Main(string[] args)
        {
            A a = new A();
            int* p = a[1];
            *p += 2;
        }
    }

ПК>Хочу, чтоб работало так же, как встроенный массив

ПК> Тем более, что на C++/CLI, если я правильно понимаю, можно такой класс сварганить, и, наверное, можно будет даже использовать его из C#, безо всяких паттернов. Ведь как-то индексация встроенных массивов в .Net сделана, почему нам нельзя?

> ПК>property T% default[int] {
> ПК>   T% get(int index) { . . . }
> ПК>   void set(T% value, int index) { . . . }
> ПК>}
> ПК>

>     unsafe class A
>     {
>         int[] _array = new int[10];
>
>         public int* this[int i]
>         {
>             get
>             {
>                 fixed (int * p = &_array[i])
>                     return p;
>             }
>         }
>     }
>

S% access(int index)
{
   return arr_[index];
}

> ПК> Хочу, чтоб работало так же, как встроенный массив

> ПК> Тем более, что на C++/CLI, если я правильно понимаю, можно такой класс сварганить, и, наверное, можно будет даже использовать его из C#, безо всяких паттернов. Ведь как-то индексация встроенных массивов в .Net сделана, почему нам нельзя?

     struct Unmanaged { };

     public value struct S
     {
         int x;
         int y;
         Unmanaged u;
     };

> T% Get() == void Get(ref T t)

void Get(T%); // можно модифицировать только сам объект, "перепривязать" ссылку нельзя

void Get(T^%); // можно модифицировать как объект, так и "перепривязать" ссылку

Q: When do you plan to allow different scope keywords for property get and set blocks? I.e. public getters with protected/private setters?
A: The next release (Whidbey or VS 2005) should have it. The current beta 1 and various "Community Tech Preview" releases should already have it...

CLS Rule 25: The accessibility of a property’s accessors shall be identical. (§8.11.3)

CLS Rule 3: Boxed value types are not CLS-compliant. (§8.2.4.)

CLS Rule 27: The type of a property shall be the return type of the getter and the type of the last argument of the setter. The types of the parameters of the property shall be the types of the parameters to the getter and the types of all but the final parameter of the setter. All of these types shall be CLS-compliant, and shall not be managed pointers (i.e., shall not be passed by reference). (§8.11.3)

ПК>В примере в MSDN было именно так. Посмотрел в тест, который написал, пока игрался (и это работало в C++/CLI)... Именно так, как написано

ПК>S% access(int index)
ПК>{
ПК>   return arr_[index];
ПК>}
ПК>

ПК>во всяком случае, я не нашел в стандарте CLI или C++/CLI упоминаний обратного. Правда, C# это дело потреблять отказался

public unsafe ref int get_Item(int index)
{
      return (int) &(this._array[index]);
}

obj.Prop++;

ПК>Дык, ты ж никогда не пробовал C++/CLI в том же объеме, что и C# — так что это не практика, это теория

std::vector<A^> vector;

template<class _T1,
    class _T2> inline
    void _Construct(_T1 _FARQ *_Ptr, const _T2& _Val)
    {    // construct object at _Ptr with value _Val
    void _FARQ *_Vptr = _Ptr;
    ::new (_Vptr) _T1(_Val);
    }

ПК>Не все затевается для C# Много вещей предназначены для "внутреннего" использования. И не хочется их ограничивать, только из-за того, что кто-то вовне чего-то там "не поймет"

ПК>     struct Unmanaged { };

ПК>     public value struct S
ПК>     {
ПК>         int x;
ПК>         int y;
ПК>         Unmanaged u;
ПК>     };
ПК>

d:\MyProjects\Tests\CppAsm\CppAsm\CppAsm.h(15) : error C4368: cannot define 'u' as a member of managed 'CppAsm::S': mixed types are not supported

d:\MyProjects\Tests\CppAsm\CppAsm\CppAsm.h(9) : error C4959: cannot define unmanaged struct 'CppAsm::Unmanaged' in /clr:safe because accessing its members yields unverifiable code

> ПК> В примере в MSDN было именно так. Посмотрел в тест, который написал, пока игрался (и это работало в C++/CLI)... Именно так, как написано

> ПК> во всяком случае, я не нашел в стандарте CLI или C++/CLI упоминаний обратного. Правда, C# это дело потреблять отказался

> public unsafe ref int get_Item(int index)
> {
>       return (int) &(this._array[index]);
> }
>

.property cpp_cli.S& named
{
       .get instance cpp_cli.S& cpp_cli.C::get_named(int32)
       .set instance void cpp_cli.C::set_named(int32, cpp_cli.S&)
}

> std::vector<A^> vector;
>

> ПК> Не все затевается для C# Много вещей предназначены для "внутреннего" использования. И не хочется их ограничивать, только из-за того, что кто-то вовне чего-то там "не поймет"

> ПК>     struct Unmanaged { };
>
> ПК>     public value struct S
> ПК>     {
> ПК>         int x;
> ПК>         int y;
> ПК>         Unmanaged u;
> ПК>     };
> ПК>

. . .

namespace cpp_cli
{
     struct Unmanaged { };

     public value struct S
     {
         int x;
         int y;
         Unmanaged u;
     };

     . . .

------ Rebuild All started: Project: cpp_cli, Configuration: Debug Win32 ------
Deleting intermediate and output files for project 'cpp_cli', configuration 'Debug|Win32'
Compiling...
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.40607.85 for 80x86
Copyright (C) Microsoft Corporation. All rights reserved.
cl /Od /AI "D:\Users\Pavel\test\CLI\cpp_cli\Debug" /D "WIN32" /D "_DEBUG" /D "_WINDLL" /D "_MBCS" /FD /EHa /MDd /GS /Yu"stdafx.h" /Fp"Debug/cpp_cli.pch" /Fo"Debug/" /Fd"Debug/vc80.pdb" /W4 /c /Zi /clr:safe /TP /FU "c:\WINDOWS\Microsoft.NET\Framework\v2.0.40607\System.dll" /FU "c:\WINDOWS\Microsoft.NET\Framework\v2.0.40607\System.Data.dll" /FU "c:\WINDOWS\Microsoft.NET\Framework\v2.0.40607\System.XML.dll"
.\cpp_cli.cpp
.\AssemblyInfo.cpp
cpp_cli.cpp
AssemblyInfo.cpp
Generating Code...
Compiling resources...
Linking...
Merging manifest files...
cpp_cli — 0 error(s), 0 warning(s)
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

> .property cpp_cli.S& named
> {
>        .get instance cpp_cli.S& cpp_cli.C::get_named(int32)
>        .set instance void cpp_cli.C::set_named(int32, cpp_cli.S&)
> }
>

III.1.8.1.2.1 A method can be defined as returning a managed pointer, but calls upon such methods are not verifiable.

[Rationale: Some uses of returning a managed pointer are perfectly verifiable (e.g., returning a reference to a field in an object); but some not (e.g., returning a pointer to a local variable of the called method). Tracking this in the general case is a burden, and therefore not included in this standard. end rationale]

#include <cli/vector>

A>У тебя Beta 2? Что-то слабо верится .

D:\VS2005\SmartDevices\SDK\PocketPC2003\Include\vector
D:\VS2005\SmartDevices\SDK\Smartphone2003\Include\vector
D:\VS2005\VC\ce\include\vector
D:\VS2005\VC\crt\src\vector
D:\VS2005\VC\include\vector

A>>У тебя Beta 2? Что-то слабо верится .

namespace cli {
template < typename T >
ref class vector : public System::Collections::Generic::IList< T >, ...
{ ... }; }

     struct Ref
     {
      object obj;
        int OffSet;
     
     }

     struct Unmanaged
     {
         int x;
         int y;
     };

int C::foo()
{
     Unmanaged u = { 10, 20 };
     u.x = u.x + u.y;
     return u.x;
}

.method public static int32 foo() cil managed
{
       // Code Size: 30 byte(s)
       .maxstack 4
       .locals (
             int32 num1,
             cpp_cli.Unmanaged unmanaged1)
       L_0000: ldloca.s unmanaged1
       L_0002: ldc.i4.s 10
       L_0004: stind.i4
       L_0005: ldloca.s unmanaged1
       L_0007: ldc.i4.4
       L_0008: add
       L_0009: ldc.i4.s 20
       L_000b: stind.i4
       L_000c: ldloca.s unmanaged1
       L_000e: ldloca.s unmanaged1
       L_0010: ldind.i4
       L_0011: ldloca.s unmanaged1
       L_0013: ldc.i4.4
       L_0014: add
       L_0015: ldind.i4
       L_0016: add
       L_0017: stind.i4
       L_0018: ldloca.s unmanaged1
       L_001a: ldind.i4
       L_001b: stloc.0
       L_001c: ldloc.0
       L_001d: ret
}