#include <afx.h>



struct Hoge

{

    int a, b, c, d, e, f, g;

};



int main()

{

    Hoge h;

    char str[] = "2374858373848 3848 28482848 2";

    CString buff(str);



    buff.Replace(" ", "");



    sscanf(buff, "%2d%3d%3d%7d%5d%4d%3d", &h.a, &h.b, &h.c, &h.d, &h.e, &h.f, &h.g);



    printf("%s\n", buff);

    printf("h.a = %d\n", h.a);

    printf("h.b = %d\n", h.b);

    printf("h.c = %d\n", h.c);

    printf("h.d = %d\n", h.d);

    printf("h.e = %d\n", h.e);

    printf("h.f = %d\n", h.f);

    printf("h.g = %d\n", h.g);



    return 0;

}

#include <afx.h>



struct Hoge

{

    char a[2 + 1];

    char b[3 + 1];

    char c[3 + 1];

    char d[7 + 1];

    char e[5 + 1];

    char f[4 + 1];

    char g[3 + 1];

};



int main()

{

    Hoge h;

    char str[] = "2374858373848 3848 28482848 2";

    CString buff(str);



    buff.Replace(" ", "");



    sscanf(buff, "%2s%3s%3s%7s%5s%4s%3s", h.a, h.b, h.c, h.d, h.e, h.f, h.g);



    printf("%s\n", buff);

    printf("h.a = %s\n", h.a);

    printf("h.b = %s\n", h.b);

    printf("h.c = %s\n", h.c);

    printf("h.d = %s\n", h.d);

    printf("h.e = %s\n", h.e);

    printf("h.f = %s\n", h.f);

    printf("h.g = %s\n", h.g);



    return 0;

}

typedef struct a

{

	a[2];

	b[3];

	c[3];

	d[7];

	e[5];

	f[4];

	g[3];

}a;



void main()

{

	a st_a;

	char str[] = {2374858373848 3848 28482848 2};

        int num [] = {2,3,3,7,5,4,3}//格配列の要素数をループなどで回す時に使用

          

        int n=0;

　　　　 for(int i=0; int =<7 ;i++)

        {

            memcpy((a+Loop[i]+n), (str+num[i]+n), num[i+1]);

            printf(格納した文字列を表示)

        }

}

#include <afx.h>



struct Hoge

{

    char a[2 + 1];

    char b[3 + 1];

    char c[3 + 1];

    char d[7 + 1];

    char e[5 + 1];

    char f[4 + 1];

    char g[3 + 1];

};



int main()

{

    Hoge h;

    char str[] = "2374858373848 3848 28482848 2";

    CString buff(str);



    buff.Replace(" ", "");



    const int sizes[] = 

    {

        sizeof(h.a) - 1,

        sizeof(h.b) - 1,

        sizeof(h.c) - 1,

        sizeof(h.d) - 1,

        sizeof(h.e) - 1,

        sizeof(h.f) - 1,

        sizeof(h.g) - 1

    };

    const char* p = buff;

    char* target = (char*)&h;

    for (int i = 0; i < sizeof(sizes) / sizeof(sizes[0]); ++i)

    {

        memcpy(target, p, sizes[i]);

        target[sizes[i]] = '\0';



        printf("%s\n", target);



        p += sizes[i];

        target += sizes[i];

    }

    

    return 0;

}

Instructions

Download instructions 



1. Click on the image download available on this page and save to your hard drive in a temporary directory. 



Because this file is large, we recommend that you use a download manager to download it.



If you do not have a download manager or are unsure, click here for a facilitated download. 

2. Rename downloaded .img files to .iso file extension and follow the ISO handling instructions below. 





Options for handling downloaded ISO Images. 

Following 2 options are available for DVD image handling.



1. Write the image file to blank DVD (Recommended)

2. Mount image file virtually as DVD devices.

For details of the options listed above, see "What are ISO image files and how do I use them?" topic available on this FAQ page. 



Installation Instructions



1. On the DVD, locate Setup.exe and double click to initiate installation.

2. Follow the Setup Wizard instructions to completion. 

3. After the Beta 2 installation has finished, you should run this script to ensure that the installation of .NET Framework 3.5 Beta 2 will not affect the development of ASP.NET AJAX 1.0 applications.

#include <utility>

#include <typeinfo>

using namespace std;



class A

{

  ...

} a;



std::pair<void*, const std::type_info*> x(&a, &typeid(a));

#include <stdio.h>



int main()

{

    for (int i = 0; i < 10; i++)

	printf("%d\n",i);

//    printf("%d\n",i);  //ここを有効にするとエラーになるかどうかで分かりますよね。

    return 0;

}

#include <stdio.h>

int main()

{

    int i;

    for (i = 0; i < 10; i++)

	printf("%d\n",i);

    int j;

    for (j = 0; j < 10; j++)

	printf("%d\n",j);

    return 0;

}

#define for if(0);else for

ARM C++ Compiler, ADS1.2 [Build 838]

#include <iostream>



class classB

{ 

public: 

    void bfunc(int, char) 

    {

        std::cout << "classB::bfunc()" << std::endl;

    }

};



class classA

{

public:

    classA()

    { 

        std::cout << "classA::classA()" << std::endl;

        m_pb = new classB(); 

        m_funcp = &classB::bfunc; 

    } 





    

    void callB(int i, char c)

    {

        std::cout << "classA::callB()" << std::endl;

        if(m_pb && m_funcp)

            (m_pb->*m_funcp)(i, c);

    }



private:

    classB * m_pb;

    void (classB::*m_funcp)(int,char);

}; 



int main(int , char *[])

{

    classA a;

    a.callB(100, 'A');

    return 0;

}

#include <iostream>



class B

{

public:

    void func(int i, char c) { std::cout << "B::func" << std::endl; }

};



class A

{

    B m_b;

    void (B::*m_func)(int, char);



public:

    A() : m_func(m_b.func) {}

    void Test() { (m_b.*m_func)(0, 0); }

};





int main()

{

    A a;

    a.Test();



    return 0;

}

#include <iostream>



class A

{

public:

    void (*m_func)(void* data);



    void Exec(void* data)

    {

        (*m_func)(data);

    }

};



class B

{

public:

    static void func(void* data)

    {

        ((B*)data)->Hoge();

    }

private:

    void Hoge()

    {

        std::cout << "B::Hoge" << std::endl;

    }

};



class C

{

public:

    static void func(void* data)

    {

        ((C*)data)->Hoge();

    }

private:

    void Hoge()

    {

        std::cout << "C::Hoge" << std::endl;

    }

};



int main()

{

    A a;

    B b;

    C c;



    a.m_func = b.func;

    a.Exec(&b);



    a.m_func = c.func;

    a.Exec(&c);



    return 0;

}

#include <iostream>

#include <boost/function.hpp>

#include <boost/bind.hpp>



class classB1

{ 

public: 

    void b1func(int i, char c) 

    {

        std::cout << i << " " << c << " classB1::bfunc()" << std::endl;

    }

};



class classB2

{ 

public: 

    void b2func(int i, char c) 

    {

        std::cout << i << " " << c << " classB2::bfunc()" << std::endl;

    }

};



void func(int i, char c) 

{

    std::cout << i << " " << c << " ::func()" << std::endl;

}





class classA

{

public:

    

    template <typename T>

    void register_function(T func)

    {

        m_function = func;

    }



    void call(int i, char c)

    {

        if(m_function)

            m_function(i, c);

    }



private:

    boost::function<void (int , char)>  m_function;

}; 



int main(int , char *[])

{

    classA a;

    a.register_function(&func);

    a.call(1, 'A');

    

    classB1 b1;

    a.register_function(boost::bind(&classB1::b1func, &b1, _1, _2));

    a.call(2, 'B');



    classB2 b2;

    a.register_function(boost::bind(&classB2::b2func, &b2, _1, _2));

    a.call(3, 'C');

    

   return 0;

}

#include <iostream>



// ----- テスト用クラス・関数

class classB1

{ 

public: 

    void b1func(int i, char c) 

    {

        std::cout << i << " " << c << " classB1::bfunc()" << std::endl;

    }

};



class classB2

{ 

public: 

    void b2func(int i, char c) 

    {

        std::cout << i << " " << c << " classB2::bfunc()" << std::endl;

    }

};



void NormalFunc(int i, char c) 

{

    std::cout << i << " " << c << " ::NormalFunc()" << std::endl;

}





// ----- 汎用呼び出しクラス

class Caller

{

public:

    

    // コンストラクタ

    Caller()    : m_holder()    {}

    

    // デストラクタ

    ~Caller()

    {

        delete m_holder;

    }

    

    // メンバ関数設定

    template <class T>

    void SetFunction(T &instance, void (T::*func)(int, char))

    {

        delete m_holder;

        m_holder = new MFuncHolder<T>(instance, func);

    }

    

    // 関数設定

    void SetFunction(void (*func)(int, char))

    {

        delete m_holder;

        m_holder = new FuncHolder(func);

    }

    

    // 呼び出し

    void Execute(int i, char c)

    {

        if(m_holder)

            m_holder->Execute(i, c);

    }

    

    

private:

    

    class HolderBase

    {

    public:

        virtual ~HolderBase()

        {

        }

        

        virtual void Execute(int, char) = 0;

    };

    

    // メンバ関数用

    template<class T>

    class MFuncHolder

        : public HolderBase

    {

    public:

        MFuncHolder(T &instance, void (T::*func)(int, char))

        : m_instance(instance), m_pMFunc(func)

        {

        }

        

    public: 

        virtual void Execute(int i, char c)

        {

            if(m_pMFunc)

                (m_instance.*m_pMFunc)(i, c);

        }

        

    private:

        T&          m_instance;

        void (T::*m_pMFunc)(int, char);

        

        MFuncHolder& operator=(const MFuncHolder &);

    };

    

    // 関数用

    class FuncHolder

        : public HolderBase

    {

    public:

        FuncHolder(void (*func)(int, char))

        : m_pFunc(func)

        {

        }

        

    public: 

        virtual void Execute(int i, char c)

        {

            if(m_pFunc)

                (*m_pFunc)(i, c);

        }

        

    private:

        void (*m_pFunc)(int, char);

    };

    

    HolderBase *        m_holder;

    

    // 一応コピー禁止

    Caller& operator=(const Caller &);

    Caller(const Caller &);

};





int main(int , char *[])

{

    Caller caller;

    

    caller.SetFunction(&NormalFunc);

    caller.Execute(1, 'A');

    

    classB1 b1;

    caller.SetFunction(b1, &classB1::b1func);

    caller.Execute(2, 'B');

    

    classB2 b2;

    caller.SetFunction(b2, &classB2::b2func);

    caller.Execute(3, 'C');

    

    return 0;

}

#include <cstdio>



class B

{

public: 

  void bfunc(int i, char c) 

  {

    std::printf("B::bfunc(%d, %c);\n", i, c);

  }

}; 



void bfunc(int i, char c) 

{

  std::printf("::bfunc(%d, %c);\n", i, c);

}



class defalt_policy

{

protected:

  ~defalt_policy() {}

};



class polymorphic_A

{

public:

  virtual void operator()(int i, char c) = 0;

  virtual ~polymorphic_A() {}

};



template<class T, class P = defalt_policy>

class A : public P

{

  T o_;

  void (T::*pmf_)(int, char);

public:

  explicit A(void (T::*pmf)(int, char)) : pmf_(pmf) {}

  void operator()(int i, char c) { (o_.*pmf_)(i, c); }

};



template<class P>

class A<void, P> : public P

{

  void (*pf_)(int, char);

public:

  explicit A(void (*pf)(int, char)) : pf_(pf) {}

  void operator()(int i, char c) { pf_(i, c); }

};



int main()

{

  A<B> a1(&B::bfunc);

  a1(123, 'a');



  A<void> a2(&::bfunc);

  a2(456, 'b');



  polymorphic_A* pa1 = new A<B, polymorphic_A>(&B::bfunc);

  (*pa1)(100, 'c');

  delete pa1;



  polymorphic_A* pa2 = new A<void, polymorphic_A>(&::bfunc);

  (*pa2)(200, 'd');

  delete pa2;



  return 0;

}

int func(int x) { 

    if (x > 1) 

        return func(x - 1); // recursive call 

    else { 

        int y = func(0) + 1; // recursive call 

        return y; 

    } 

}