coffee 点了我的名，我就来剖析一下自己 

[转贴]游戏规则：

1．被点到名字的要把所有的问题像我一样回答出来发一篇日志在自己的页面上，所有的 问题都要答。最后去掉一个（任意一个）问题，再提一个自己的问题，凑够30个。再点出另外八个人继 续回答，并列出这八个人的名字。还要到这八个人的页面留言通知对方——你被点名了。 被点名者不得拒绝回答问题。

2.这八个人要在自己的日志里注明是从哪里接到的，并且再想一个问题传给其他八个人 ,让游戏继续下去，不得回传。被点到名字的人将会得到大家的祝福，并且所有美好的愿 望都会在不久的将来实现

1.你愿意毁了生活，还是愿意让生活毁了你？

   有种就来毁我，看谁彪悍

2.你会先结婚后恋爱？当然是和同一个人，理由？

   跟喜欢的人？ 可以try

3 .相信真正的爱情只有3个月的理论吗?

   不会那么短的

４.什么样的人才值得你爱？ 

   有思想 知道自己在干什么 尊重别人 

5.与朋友产生误会,你会怎么办?

   一个职业电话销售人员不会让人误会自己，我也一样

６.你小时侯的梦想是什么?

   地质学家，让我表妹作助手

7 .你最理想的生活状态是什么？

    毁掉所多玛和蛾摩拉，如果上帝没有能力的话

８.如果你只能实现自己的一个愿望，你会许什么

   拥有制作绝世美食的能力

９.最喜欢的食物是什么？

    羊杂碎

10.喜欢直发还是卷发？

    光头

11.你最讨厌什么动物？

    猪，我不愿意有其他动物模仿我

1２.结了婚还可以偷偷喜欢其他人吗？

    不道德，不过YY也可以了

1３.最喜欢什么饮料？

    肉汤

14.你喜欢太阳吗？

     喜欢 

15.如果明天就是世界末日，那你今天会做什么？

     跑步和推杠铃，让我的肌肉兴奋，死也要死的像个英雄，不能像平时一样猥琐

16.如果两个好朋友背着你在一起了,你还会继续跟她/他做朋友吗?

     这种事情我持反对态度，不过不影响友谊

17 .如果旧爱回来你会重新开始吗？

     没兴趣

18.冲动怎么克制自己？

     把想做的做了

19.如果你爱的人骗了你,当他/她再次让你给他/她一次机会时,你怎么办啊?

   能骗了我，那就给我当老师吧

20、人活着到底爲什麽？

     了解别人的胃口，并作出对人家胃口的菜

21.走自己的路，可以不在乎别人说什么吗？

     我在乎别人的评价

22、朋友不在身邊，會感到寂寞嗎？

     常常

23.发现自己喜欢上一个人要多久？

    很漫长 

24、最想為妳的那位做的一件事是什麽？

     让她有个好胃口

25、妳相信緣分嗎？

   相信

26.对我最大的期望是什么？

    可以搞定Statistical Learning

27.人要是没有了睡觉的功能，你觉得好还是不好？

   好

28. 最让你怀念的学生时代是什么时候（幼儿园小学初中高中大学）？为什么？

      大学

29  你最近发生的一件糗事是什么？

      被西藏禁书吓到 

30 我的问题：最让你怀念的一件事 

     10年前 不知多少个冬季早晨， 在寒风中 我在自由路上的 羊杂碎早点铺子吃得不亦乐乎...

点名： Don Cutting, Duke, Billy, Jimmy, Vapnik, Thomas Cormen, Stawlt, Eric

from http://www.icce.rug.nl/documents/cplusplus/cplusplus10.html#l166

The book "C++ Annotations"  is helpful to those need refer some basic grammar of CPP.

http://www.icce.rug.nl/documents/cplusplus/cplusplus.html

Chapter 10: Static data and functions

Don't hesitate to send in feedback: send an e-mail if you like the C++ Annotations; if you think that important material was omitted; if you find errors or typos in the text or the code examples; or if you just feel like e-mailing. Send your e-mail to Frank B. Brokken.

Please state the document version you're referring to, as found in the title (in this document: 6.5.0) and please state chapter and paragraph name or number you're referring to.

All received mail is processed conscientiously, and received suggestions for improvements will usually have been processed by the time a new version of the Annotations is released. Except for the incidental case I will normally not acknowledge the receipt of suggestions for improvements. Please don't interpret this as me not appreciating your efforts.

In the previous chapters we have shown examples of classes where each object of a class had its own set of public or private data. Each public or private member could access any member of any object of its class.

In some situations it may be desirable that one or more common data fields exist, which are accessible to all objects of the class. For example, the name of the startup directory, used by a program that recursively scans the directory tree of a disk. A second example is a flag variable, which states whether some specific initialization has occurred: only the first object of the class would perform the necessary initialization and would set the flag to `done'.

Such situations are analogous to C code, where several functions need to access the same variable. A common solution in C is to define all these functions in one source file and to declare the variable as a static: the variable name is then not known beyond the scope of the source file. This approach is quite valid, but violates our philosophy of using only one function per source file. Another C-solution is to give the variable in question an unusual name, e.g., _6uldv8, hoping that other program parts won't use this name by accident. Neither the first, nor the second C-like solution is elegant.

C++'s solution is to define static members: data and functions, common to all objects of a class and inaccessible outside of the class. These static members are the topic of this chapter.

10.1: Static data

Static data members are created when the program starts. Note, however, that they are always created as true members of their classes. It is suggested to prefix static member names with s_ in order to distinguish them (in class member functions) from the class's data members (which should preferably start with d_).

Public static data members are like `normal' global variables: they can be accessed by all code of the program, simply using their class names, the scope resolution operator and their member names. This is illustrated in the following example:

    class Test
    {
        static int s_private_int;

        public:
            static int s_public_int;
    };

    int main()
    {
        Test::s_public_int = 145;   // ok

        Test::s_private_int = 12;   // wrong, don't touch
                                    // the private parts
        return 0;
    }

10.1.1: Private static data

    class Directory
    {
        static char s_path[];

        public:
            // constructors, destructors, etc. (not shown)
    };

Since constructors are called for each new object of a class, static data members are never initialized by constructors. At most they are modified. The reason for this is that static data members exist before any constructor of the class has been called. Static data members are initialized when they are defined, outside of all member functions, in the same way as other global variables are initialized.

The definition and initialization of a static data member usually occurs in one of the source files of the class functions, preferably in a source file dedicated to the definition of static data members, called data.cc.

The data member s_path[], used above, could thus be defined and initialized as follows in a file data.cc:

    include "directory.ih"

    char Directory::s_path[200] = "/usr/local";

Note that any source file could contain the definition of the static data members of a class. A separate data.cc source is advised, but the source file containing, e.g., main() could be used as well. Of course, any source file defining static data of a class must also include the header file of that class, in order for the static data member to be known to the compiler.

A second example of a useful private static data member is given below. Assume that a class Graphics defines the communication of a program with a graphics-capable device (e.g., a VGA screen). The initialization of the device, which in this case would be to switch from text mode to graphics mode, is an action of the constructor and depends on a static flag variable s_nobjects. The variable s_nobjects simply counts the number of Graphics objects which are present at one time. Similarly, the destructor of the class may switch back from graphics mode to text mode when the last Graphics object ceases to exist. The class interface for this Graphics class might be:

    class Graphics
    {
        static int s_nobjects;              // counts # of objects

        public:
            Graphics();
            ~Graphics();                    // other members not shown.
        private:
            void setgraphicsmode();         // switch to graphics mode
            void settextmode();             // switch to text-mode
    }

    int Graphics::s_nobjects = 0;           // the static data member

    Graphics::Graphics()
    {
        if (!s_nobjects++)
            setgraphicsmode();
    }

    Graphics::~Graphics()
    {
        if (!--s_nobjects)
            settextmode();
    }

10.1.2: Public static data

    int main()
    {
        getcwd(Directory::s_path, 199);
    }

10.1.3: Initializing static const data

    class X
    {
        public:
            enum Enum
            {
                FIRST,
            };

            static int const s_x = 34;
            static Enum const s_type = FIRST;

            static double const s_d = 1.2;
            static string const s_str = "a";    // won't compile
    };

A statement like int *ip = &X::s_x will therefore compile correctly, but will fail to link. Static variables that are explicitly defined in a source file can be linked correctly, though. So, in the following example the address of X::s_x cannot be solved by the linker, but the address of X::s_y can be solved by the linker:

    class X
    {
        public:
            static int const s_x = 34;
            static int const s_y;
    };

    int const X::s_y = 12;

    int main()
    {
        int const *ip = &X::s_x;    // compiles, but fails to link
        ip = &X::s_y;               // compiles and links correctly
    }

10.2: Static member functions

Static member functions can access all static members of their class, but also the members (private or public) of objects of their class if they are informed about the existence of these objects, as in the upcoming example. Static member functions are themselves not associated with any object of their class. Consequently, they do not have a this pointer. In fact, a static member function is completely comparable to a global function, not associated with any class (i.e., in practice they are. See the next section (10.2.1) for a subtle note). Since static member functions do not require an associated object, static member functions declared in the public section of a class interface may be called without specifying an object of its class. The following example illustrates this characteristic of static member functions:

    class Directory
    {
        string d_currentPath;
        static char s_path[];

        public:
            static void setpath(char const *newpath);
            static void preset(Directory &dir, char const *path);
    };
    inline void Directory::preset(Directory &dir, char const *newpath)
    {
                                                    // see the text below
        dir.d_currentPath = newpath;                // 1
    }

    char Directory::s_path[200] = "/usr/local";     // 2

    void Directory::setpath(char const *newpath)
    {
        if (strlen(newpath) >= 200)
            throw "newpath too long";

        strcpy(s_path, newpath);                    // 3
    }

    int main()
    {
        Directory dir;

        Directory::setpath("/etc");                 // 4
        dir.setpath("/etc");                        // 5

        Directory::preset(dir, "/usr/local/bin");   // 6
        dir.preset(dir, "/usr/local/bin");          // 7
    }

• at 1 a static member function modifies a private data member of an object. However, the object whose member must be modified is given to the member function as a reference parameter.

  Note that static member functions can be defined as inline functions.

• at 2 a relatively long array is defined to be able to accomodate long paths. Alternatively, a string or a pointer to dynamic memory could have been used.
• at 3 a (possibly longer, but not too long) new pathname is stored in the static data member s_path[]. Note that here only static members are used.
• at 4, setpath() is called. It is a static member, so no object is required. But the compiler must know to which class the function belongs, so the class is mentioned, using the scope resolution operator.
• at 5, the same is realized as in 4. But here dir is used to tell the compiler that we're talking about a function in the Directory class. So, static member functions can be called as normal member functions.
• at 6, the currentPath member of dir is altered. As in 4, the class and the scope resolution operator are used.
• at 7, the same is realized as in 6. But here dir is used to tell the compiler that we're talking about a function in the Directory class. Here in particular note that this is not using preset() as an ordinary member function of dir: the function still has no this-pointer, so dir must be passed as argument to inform the static member function preset about the object whose currentPath member it should modify.

In the example only public static member functions were used. C++ also allows the definition of private static member functions: these functions can only be called by member functions of their class.

10.2.1: Calling conventions

In practice these calling conventions are identical, implying that the address of a static member function could be used as an argument in functions having parameters that are pointers to (global) functions.

If unpleasant surprises must be avoided at all cost, it is suggested to create global classless wrapper functions around static member functions that must be used as call back functions for other functions.

Recognizing that the traditional situations in which call back functions are used in C are tackled in C++ using template algorithms (cf. chapter 17), let's assume that we have a class Person having data members representing the person's name, address, phone and weight. Furthermore, assume we want to sort an array of pointers to Person objects, by comparing the Person objects these pointers point to. To keep things simple, we assume that a public static

    int Person::compare(Person const *const *p1, Person const *const *p2);

Most compilers will allow us to pass this function's address as the address of the comparison function for the standard C qsort() function. E.g.,

    qsort
    (
        personArray, nPersons, sizeof(Person *),
        reinterpret_cast<int(*)(const void *, const void *)>(Person::compare)
    );

    int compareWrapper(void const *p1, void const *p2)
    {
        return
            Person::compare
            (
                reinterpret_cast<Person const *const *>(p1),
                reinterpret_cast<Person const *const *>(p2)
            );
    }

    qsort(personArray, nPersons, sizeof(Person *), compareWrapper);

• The wrapper function takes care of any mismatch in the calling conventions of static member functions and classless functions;
• The wrapper function handles the required type casts;
• The wrapper function might perform small additional services (like dereferencing pointers if the static member function expects references to Person objects rather than double pointers);
• As noted before: in current C++ programs functions like qsort(), requiring the specification of call back functions are seldomly used, in favor of existing generic template algorithms (cf. chapter 17).

6 steps to creating a super startup

Thinking about starting a business? Follow these crucial tips and your company might just become the next big thing.

(Fortune Small Business) -- If you want to be an entrepreneur, you're in good company. An average of 464,000 adults a month create new businesses, according to the most recent statistics available from the Kauffman Foundation (kauffman.org), which tracks and promotes entrepreneurship.

But starting a business is a complicated, risky, all-consuming effort. Indeed, just two-thirds of new small businesses survive at least two years, and only 44 percent survive at least four years, according to a study by the U.S. Small Business Association.

Get expert tips, links, tools and lists on...

  Startup

  Technology

  Green business

  Entrepreneurial women, minorities, kids, more

More from FSB

Risks of running an ethical business 6 steps to creating a super startup Do you need a $2,600 tablet PC?

Current Issue

Quiz Take the quiz

Are you ready to start your own business? Being your own boss may sound great, but not everyone has what it takes to succeed as an entrepreneur. Do you? 1. If I have to, I'm willing to lower my standard of living for a while - take fewer (or no) vacations and cut back on nonessentials like eating out - while trying to get my business off the ground. True False

Taking the six steps below will help put you on the road to success.

1. Determine if you're an entrepreneur or just a wannabe. Starting a successful business requires a unique set of characteristics. You have to be willing to take calculated risks. In addition, a mix of optimism, high energy, and an ability to live with ambiguity are also crucial.

According to a recent study of 1,600 Columbia Business School alumni who started businesses, the desire most related to success was the inclination to build something.

"They took a long-term view," says Murray Low, director of the Eugene M. Lang Center for Entrepreneurship at Columbia.

Make sure you're prepared to wear many hats, at least in the beginning. "You need to be willing to meet with the chairman of the board, then go back to the office and fix the toilet," says Low.

2. Pinpoint an opportunity. There are lots of ways to find the right business idea. But for most people, it's wise to begin with your interests, say small-business experts.

"You should start with what you know best and are most passionate about," says Sarah Chiles, director of Programs at NYU Stern's Berkley Center for Entrepreneurial Studies.

Back in 1999, Julie Dix started sewing satin tags onto her baby's blankets, after she discovered the infant liked playing with soft edges. Soon, other mothers began telling her what a great idea it was. That's when she teamed with friend Danielle Ayotte and formed Spencer, Mass.-based Taggies. Today, the company sells the blankets, and dozens of other products in six countries.

The bottom line: "You have to find an underlying need that's not being fully met," says Timothy Faley, managing director of the Samuel Zell & Robert H. Lurie Institute for Entrepreneurial Studies at the University of Michigan's Ross School of Business.

3. Make sure there's a market for your idea. Get out there and talk to as many potential customers, suppliers and distributors as you can. Trade-show attendees are a particularly good source of information. And remember: You're not trying to sell anything yet; you're just exploring the opportunity.

"Everyone will be more willing to talk if they think you're just looking for information," says Faley.

It's also a good idea to make a prototype of your product, so customers can test it out. That goes even for low-tech wares. Early on, Dix and Ayotte made samples and brought them to crafts fairs, as well a local store. When it sold out in just a few days, they knew they were onto something.

As you get feedback, good or bad, fine-tune your concept accordingly.

4. Write a business plan. Any plan needs to answer a few key questions: What is your product or service? Who is your customer? What need does it address? And, how are you going to turn your idea into a money-making venture?

The plan "should lay the foundation on which you build your business," says Faley.

Divide the document into a few sections. First, and perhaps most important, is the executive summary, detailing in no more than two pages the key information in your plan.

Next should be a market analysis that describes the needs you're addressing and any potential competitors; a discussion of your marketing plans and the management team; and a financial analysis of the first five years in business, with a sample income statement and balance sheet.

Be prepared to revisit the plan many times. "It should grow and change along with your company," says Faley.

5. Determine your business structure. You have four basic choices -- sole proprietorship, partnership, LLC, or corporation. Each offers different legal protections, tax savings, and ownership requirements. They also vary in how complicated they are to set up.

For example, sole proprietorships and partnerships require little paperwork to establish, but also don't provide the tax breaks and liability protections of other structures.

With limited liability companies (LLCs), you are personally protected from creditors and lawsuits and can have as many owners as you'd like.

Corporations also shield your personal assets from creditors and provide various tax breaks. If you incorporate as a C corporation, owners are not responsible for liabilities, because the corporation is considered to be a separate legal entity. But there's also a double taxation, on both earned dividends and profits. An S corporation avoids that problem by having shareholders report earnings on their personal tax forms. But there are limitations on who and how many people can be shareholders.

6. Look for funding. Most entrepreneurs start their businesses by dipping into their savings, and hitting up friends and family. Perhaps half of all startups, in fact, are funded initially by the founder's credit cards, according to Faley.

Getting a bank loan is tough unless you have assets - and that often means using your home as collateral.

Other likely sources include potential suppliers and even prospective customers, who might be willing to help out in return for steep discounts.

What about venture capital? Fact is, VCs rarely invest in startups.

Shell Script设计要点