Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.stroustrup.com/bsfaq2cn.html below:

Bjarne Stroustrup's C++ Style and Technique FAQ（ä¸æ–‡ç‰ˆï¼‰

• 开始：
  • 您可以推荐一种编写代码的标准吗？
• 类：
  • C++ 的对象在内存中的存放形式是怎么样的？
  • 为什么“this”不是引用？
  • 为什么（对象）退出作用域时没有调用析构函数？
  • “友元”违反了封装吗？
  • 为什么我的构造函数不太对劲？
• 类继承体系：
  • 什么是纯虚函数？
  • 为何 C++ 没有 final 关键字
  • 为什么 C++ 没有通用类对象？
• 模板与泛型编程：
  • 为何 vector<Apple*> 不能赋值给 vector<Fruit*>？
  • 模板（templates）本应被设计为“泛型（generics）”那样吗？
  • 为何 C++ 不提供多态的容器？
  • 为何标准容器效率如此低下？
• 内存：
  • “new”和“malloc()”的不同点何在？
  • 数组有何不好之处？
• 异常：
  • 如何使用异常？
  • 可以在构造函数里抛出异常吗？析构函数里呢？
• 其它语言特性：
  • C++ 中如何调用 C 函数？
  • C 中如何调用 C++ 函数？
  • 为何 C++ 既有指针也有引用？
  • 我应该使用 NULL 还是 0？
  • i++ + i++ 的值是多少？
  • 为何 C++ 里有些东西是未定义的呢？
  • static_cast 有什么好处？
• 琐事及风格：
  • “cout”怎么念？
  • “char”怎么念？
  • 你如何命名变量？是否推荐匈牙利命名法？
  • 我应该使用按值传递还是按引用传递？

        C++ 代码编写标准的要点是：根据使用 C++ 的具体的环境和具体目的制定一套规则。因此，没有哪一种代码编写标准是符合所有需要和所有用户的。对于一个特定的应用程序（或者公司、应用领域，等等）来 说，一种好的代码编写标准当然比没有标准要好得多。话说回来，我看到过很多例子表明一种差劲的代码编写标准比没有标准还要更糟糕。

        é€‰æ‹©è§„则时，请切记细心，而且你必须对该应用领域有过硬的知识。一些最差劲的代码编写标准（“为了保护罪犯”，我不 会提及这些名字）的作者既没有过硬的 C++ 知识，而且对其应用领域也相对无知（他们是“专家”，而非开发人员），更误以为约束总是多比少好。针对前面这种 误解的一个反例是：某些特性的存在会导致程序员不得不使用甚至更糟糕的特性。怎么都好，请牢记，安全性、生产率等是设计和开发过程的所有部分的总和 ——而非各种语言特性的总和，更不是所有语言的总和。

        åŸºäºŽä»¥ä¸ŠåŽŸå› ï¼Œæˆ‘的推荐有三：

• 看 Sutter 和 Alexandrescu 合著的《C++ 代码编写标准（C++ Coding Standards）》。Addison-Wesley 出版，ISBN 0-321-11358-。这本书里有很多好的规则，但请把这些规则看作一套元规则（meta-rules）。更明确地说，就是把这本书当作一本关于 “一套优秀的代码编写规则应该是怎么样的”的指南。如果你正在写代码编写标准，不看这本书将是一大损失。
• 看 JSF 航空器 C++ 代码编写标准。 我认为这是一套关于编写对安全性和性能要求苛刻的代码的优秀规则。如果你从事嵌入式系统编程，那你应该考虑看一下这份标准。告诫：我参与了这些规则的制 定，所以你可以认为我带有偏心。话说回来，请将你对这份标准的建设性意见发给我。这些意见可能会推动这份标准的改进——所有优秀 的标准都会定期地被重新审视，并且根据经验和工作环境的变化而更新。如果你不是在构建苛刻的实时系统或者对安全性要求苛刻的系统，那 你会觉得这些规则过于严格——毕竟这些规则并非为你而设（至少并非所有这些规则都是为你而设的）。
• 不要使用 C 语言代码编写标准（即使已将其修改为 C++ 版），也不要使用 10 年前的 C++ 代码编写标准（即使在那时来说是很优秀的标准）。C++ 并非（仅仅）是 C，而标准 C++ 也并非（仅仅）是标准前的 C++。

        å’Œ C 一样，C++ 也没有定义对象在内存中的存放形式，而仅仅定义了一些必须遵循的语义约束。因此，不同的编译器实现起来都有所不同。不幸的是，我知道的最好的解释出自于一 本过时的书，而且这本书并没有描述任何当前的 C++ 实作——《带评注的 C++ 参考手册》（The Annotated C++ Reference Manual，常简称为 ARM）。该书有一些存放形式的图例。TC++PL 第二章也有一个简短的解释。

        åŸºæœ¬ä¸Šï¼ŒC++ 简单地通过连接各个子对象来构建对象。例如：

                struct A { int a,b; };

        åœ¨å†…存中的表现就是两个 int 型变量彼此相邻。又如：

                struct B : A { int c; };

        åœ¨å†…存中的表现是类型为 A 的对象和 int 型变量彼此相邻，c 跟在 A 型对象的后面；也就是说，a 和 b 彼此相邻，b 和 c 彼此相邻。

        è™šå‡½æ•°é€šå¸¸æ˜¯é€šè¿‡åœ¨å«æœ‰è™šå‡½æ•°çš„类的每个对象中加入一个指针（vptr）来实现的。这个指针指向一个相应的函数表（vtbl）。每个类都有其独 特的 vtbl，所有属于同一个类的对象共享同一个 vtbl。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#layout-obj

        å› ä¸º“this”被引入 C++（事实上那时还是带类的 C）的时候，还没有引用（reference）这个概念。同样地，我遵循 Simula 的用法而选择了“this”这个词，而不是（后来）Smalltalk 的“self”。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#this

        æœ€ç®€å•çš„答案是“肯定会调用！”，不过还是先来看看一个经常伴随着这个问题的例子吧：

                void f()
                {
                        X* p = new X;
                        // use p
                }

        ä¹Ÿå°±æ˜¯è¯´ï¼Œæœ‰äº›äººè¯¯ä»¥ä¸º new 创建的对象会在函数的最后被析构。

        åŸºæœ¬ä¸Šï¼Œåªæœ‰å½“你希望一个对象能“生存”于其被创建的域之外时，才应该使用“ new”。若然如此，你就需要使用“delete”来析构该对象。例如：

                X* g(int i) { /* ... */ return new X(i); } // the X outlives the call of g()

                void h(int i)
                {
                        X* p = g(i);
                        // ...
                        delete p;
                }

        å¦‚果你希望一个对象只能“生存”于一个域中，那就不要使用“new”，而应该单纯地定义一个变量：

                {
                        ClassName x;
                        // use x
                }

        å˜é‡åœ¨é€€å‡ºä½œç”¨åŸŸæ—¶ä¼šè¢«éšå¼æžæž„。

        åœ¨åŒä¸€ä¸ªåŸŸä¸­ä½¿ç”¨ new 创建对象，然后使用 delete 来将之析构不但难看，而且容易出错，更是效率低下。例如：

                void fct() // ugly, error-prone, and inefficient
                {
                        X* p = new X;
                        // use p
                        delete p;
                }

原文地址：http://www.research.att.com/~bs/bs_faq2.html#delete-scope

        ä¸ï¼Œå¹¶éžå¦‚此。和成员函数类似，“友元”是一种显式地授予访问权限的机制。你不能（于一个符合标准的 程序）在不修改源代码的情况下授予你访问类的权限。例如：

                class X {
                        int i;
                public:
                        void m(); // grant X::m() access
                        friend void f(X&); // grant f(X&) access
                        // ...
                };

                void X::m() { i++; /* X::m() can access X::i */ }

                void f(X& x) { x.i++; /* f(X&) can access X::i */ }

        æƒ³äº†è§£ C++ 的（数据）保护模型，可参考 D&E 章节 2.10 以及 TC++PL 章节 11.5、15.3，以及 C.11。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#friend

        ç±»ä¼¼è¿™æ ·çš„问题千奇百怪。例如：

• 为什么我明明不想复制对象，而编译器却偏偏这么做了呢？
• 如何关闭复制机制？
• 如何防止隐式转换？
• 为何 int 自动转换成了复数？

                struct Point {
                        int x,y;
                        Point(int xx = 0, int yy = 0) :x(xx), y(yy) { }
                };

                Point p1(1,2);
                Point p2 = p1;

        è‡³æ­¤ï¼Œp2.x==p1.x 并且 p2.y==p1.y。这可能正是你想要的（而且也是为了和 C 兼容所必需的），但是，以下代码：

                class Handle {
                private:
                        string name;
                        X* p;
                public:
                        Handle(string n)
                                :name(n), p(0) { /* acquire X called "name" and let p point to it */ }
                        ~Handle() { delete p; /* release X called "name" */ }
                        // ...
                };

                void f(const string& hh)
                {
                        Handle h1(hh);
                        Handle h1 = h2; // 会引起灾难！
                        // ...
                }

        åœ¨æ­¤ï¼Œé»˜è®¤å¤åˆ¶æž„造函数使得 h2.name==h1.name 并且 h2.p==h2.p。这将导致一场灾难：当函数 f() 运行结束时，会调用 h1 和 h2 的析构函数，这就导致 h1.p 和 h2.p 所指向的对象被 delete 了两次。

        å¦‚何避免这场灾难？最简单的办法是，将复制构造函数和赋值运算符声明为私有成员，从而关闭复制机制：

                class Handle {
                private:
                        string name;
                        X* p;

                        Handle(const Handle&); // 阻止复制
                        Handle& operator=(const Handle&);
                public:
                        Handle(string n)
                                :name(n), p(0) { /* acquire the X called "name" and let p point to it */ }
                        ~Handle() { delete p; /* release X called "name" */ }
                        // ...
                };

                void f(const string& hh)
                {
                        Handle h1(hh);
                        Handle h1 = h2; // 编译器报错
                        // ...
                }

        å¦‚果需要复制机制，我们可以定义自己的复制构造函数和赋值运算符，让它们按我们期待的那样工作。

        çŽ°åœ¨å›žè¿‡å¤´æ¥å†çœ‹çœ‹ç±» Point。对 Point 来说，可以使用默认的复制机制，但它的构造函数有点问题：

                struct Point {
                        int x,y;
                        Point(int xx = 0, int yy = 0) :x(xx), y(yy) { }
                };

                void f(Point);

                void g()
                {
                        Point orig; // 使用默认值 (0,0) 创建 orig
                        Point p1(2); // 使用 yy 的默认值 (0) 来创建 p1
                        f(2); // 调用 Point(2,0);
                }

        ä¸ºäº†ä¾¿äºŽåˆ›å»ºå¯¹è±¡ï¼ˆå¦‚这里的 orig 和 p1），我们为 Point 的构造函数提供了默认参数。然后，有些人会感到惊讶的事情发生了：调用 f() 时，2 会转换成 Point(2,0)。当我们定义一个接受单个参数的构造函数时，同时亦定义了一种类型转换方式。默认情况下，类型转换是隐式进行的。若想把类型转换改成 显式进行，就要将构造函数声明为 explicit：

                struct Point {
                        int x,y;
                        explicit Point(int xx = 0, int yy = 0) :x(xx), y(yy) { }
                };

                void f(Point);

                void g()
                {
                        Point orig; // 使用默认值 (0,0) 创建 orig
                        Point p1(2); // 使用 yy 的默认值 (0) 来创建 p1
                                            // 显式调用构造函数
                        f(2); // 错误（试图进行隐式转换）
                        Point p2 = 2; // 错误（试图进行隐式转换）
                        Pont p3 = Point(2); // 正确（显式转换）
                }

原文地址：http://www.research.att.com/~bs/bs_faq2.html#explicit-ctor

        çº¯è™šå‡½æ•°æ˜¯æŒ‡ä¸å¿…在基类中定义，但必须在派生类中被覆盖（override）的函数。通过新奇的“=0”语法可将虚函数声明为纯虚函数。例如：

                class Base {
                public:
                        void f1();                         // 不是虚函数
                        virtual void f2();         // 是虚函数，但不是纯虚函数
                        virtual void f3() = 0;  // 纯虚函数
                };

                Base b; // error: pure virtual f3 not overridden

        åœ¨æ­¤ï¼ŒBase 是抽象类（因为它有一个纯虚函数），所以不能直接用它来定义对象：Base（很显然）是用来做基类的。例如：

                class Derived : public Base {
                        // 没有定义 f1：没关系
                        // 没有定义 f2：没关系，继承了 Base::f2
                        void f3();
                };

                Derived d; // ok: Derived::f3 覆盖了 Base::f3

        æŠ½è±¡ç±»æ˜¯å®šä¹‰æŽ¥å£çš„非常好的工具。事实上，一个只有纯虚函数的类通常被称为接口。

        å½“然你也可以定义纯虚函数：

                Base::f3() { /* ... */ }

        è¿™æ ·åšå¾€å¾€æ„ä¹‰ä¸å¤§ï¼ˆè™½ç„¶è¿™æ ·åšå¯ä¸ºæ´¾ç”Ÿç±»æä¾›ä¸€äº›ç®€å•çš„公共代码），而且在派生类中仍然需要覆盖 Base::f3()。

        å¦‚果你没有在派生类中覆盖纯虚函数，那该派生类也是抽象类：

                class D2 : public Base {
                        // 没有定义 f1：没关系
                        // 没有定义 f2：没关系，继承了 Base::f2
                        // 没有定义 f3：没关系，但 D2 因此也是抽象类
                };

                D2 d; // 错误：没有覆盖纯虚函数 Base::f3

原文地址：http://www.research.att.com/~bs/bs_faq2.html#pure-virtual

因为无论过去，还是现在，都没有这个必要。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#final

• 我们不需要这个：大多数情况下，泛型编程提供的静态类型安全机制是非常不错的替代品。其它情况可使用多继承（multiple inheritance）来解决。
• 不存在有用的通用类：纯粹的通用类本身不含任何语义。
• “通用”类会怂恿人们对类型和接口的考虑粗枝大叶，从而导致多余的运行时检查。
• 使用通用基类意味着额外花销：为了使用多态，对象必须在堆中分配；这就会导致额外的内存及访问花销。堆对象天生就不支持复制语义（copy semantics）。堆对象没有作用域的概念（这导致资 源管理变得复杂化）。通用基类会怂恿 dynamic_cast 的使用及其它运行时检查。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#object

        å› ä¸ºè¿™å°†é™ä½Žç±»åž‹ç³»ç»Ÿçš„安全性。例如：

                class Apple : public Fruit { void apple_fct(); /* ... */ };
                class Orange : public Fruit { /* ... */ }; // Orange 没有 apple_fct()

                vector<Apple*> v; // vector of Apples

                void f(vector<Fruit*>& vf) // innocent Fruit manipulating function
                {
                        vf.push_back(new Orange); // 将 Orange 对象指针加入 vf
                }

                void h()
                {
                        f(v); // 错误：不能传递 vector 给 vector
                        for (int i=0; i <v.size(); ++i) v[i]- >apple_fct();
                }

        å¦‚果调用 f(v) 是合法的，我们将得到伪装成 Apple 的 Orange。

        当然，也可以把语言设计成允许这种不安全的类型转换，然后依赖动态类型检查保证访问的合法性。这将导致每次访问 v 的成员时，都要进行运行时检查，而且 h() 也必须在遇到 v 的最后一个元素后抛出异常。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#conversion

        éžä¹Ÿã€‚generics 其实是为抽象类而设的语法；亦即，利用 generics（无论是 Java generics 或 C# generics），你从此不再需要定义精确的接口，但相对地，你也要为此付出诸如虚函数调用以及/或者动态类型转换的花销。

        Templates 通过其各种特性的组合（整型模板参数（integer template arguments）、特化（specialization）、同等对待内建/用户定义类型等），可支持泛型编程（generic programming）、模板元编程（template metaprogramming）等。Templates 带来的灵活性、通用性，以及性能都是“generics”不能比美的。STL 就是最好的例子。

        ä¸è¿‡ï¼ŒTemplates 带来灵便的同时，亦带来了一些不尽人意的后果——错误检查滞后、出错信息非常糟糕。目前，可通过 constraints classes 间接解决这个问题。C++0x 将引入 concepts 来直接解决这个问题（参考我的论文、提案，以及标 准委员会网站的所有提案）。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#generics

	    vector<int> vi(10);
	    vector<Shape*> vs;
	    list<string> lst;
	    list<double> l2
	    map<string,Record*> tbl;
	    map< Key,vector<Record*> > t2;

        这些容器都是单态的；亦即，它们的元素是同一类型的。如果你希望某个容器能保存多种类型的元素，必须使用联合体或者在容器里保存指向多态类型的指针（这个方法通常更好）。一个经典的例子是：

	    vector<Shape*> vi; // 该 vector 保存指向 Shape 的指针

        所以，可以说，所有容器（无论任何语言）都是单态的，因为为了使用它们，必须有一个可供用户用来访问其中所有元素的公共接口。提供多态容器的语言，其实无 非是容器里的元素都提供了一个标准的接口。例如，Java collection 提供的容器保存的是 Object 类型（的引用），可用（公共的）Object 接口来获取元素的真正类型。

        C++ 标准库提供单态的容器，因为大多数情况下，它们常用且易用，并能提供尽可能好的编译时错误信息，而且没有不必要的运行时开销。

	    class Io_obj { /* ... */ }; // 进行 I/O 所需的接口
	    vector<Io_obj*> vio;    // 如果你想直接管理指针

	    vector< Handle<Io_obj> > v2; // 如果你想用“智能指针”来处理各个对象

	    vector<void*> memory; // 很少用到

        在某些程序里，也可以使用 Any 类（例如 Boost::Any）：

	    vector<Any> v;

原文地址：http://www.research.att.com/~bs/bs_faq2.html#containers

• 复制开销
• 查表很慢
• 我写的（浸入式）链表比 std::list 要快得多

原文地址：http://www.research.att.com/~bs/bs_faq2.html#slow-containers

原文地址：http://www.research.att.com/~bs/bs_faq2.html#malloc

• 数组不知道其自身的长度
• 稍有风吹草动，数组的名字就会转换成指向其首元素的指针

原文地址：http://www.research.att.com/~bs/bs_faq2.html#arrays

原文地址：http://www.research.att.com/~bs/bs_faq2.html#exceptions

• 可以：当你不能正常地初始化（构造）对象时，你应该在构造函数里抛出异常。没有任何其它方法比抛出异常退出构造函数更合适了。
• 不然：你可以在析构函数里抛出异常，但这个异常必须不能越过析构函数；如果因为抛出异常而退出了析构函数，任何糟糕的情况都可能发生，因为这违反了标准库及 C++ 语言本身的基本规则。不要这么做。

原文地址：http://www.research.att.com/~bs/bs_faq2.html#ctor-exceptions

原文地址：http://www.research.att.com/~bs/bs_faq2.html#callC

原文地址：http://www.research.att.com/~bs/bs_faq2.html#callCpp

原文地址：http://www.research.att.com/~bs/bs_faq2.html#pointers-and-references

原文地址：http://www.research.att.com/~bs/bs_faq2.html#null

原文地址：http://www.research.att.com/~bs/bs_faq2.html#evaluation-order

原文地址：http://www.research.att.com/~bs/bs_faq2.html#undefined

原文地址：http://www.research.att.com/~bs/bs_faq2.html#static-cast

原文地址：http://www.research.att.com/~bs/bs_faq2.html#cout

原文地址：http://www.research.att.com/~bs/bs_faq2.html#char

原文地址：http://www.research.att.com/~bs/bs_faq2.html#Hungarian

• 如果你想改变被传递的对象，那就按引用传递或者使用指针；例如 void f(X&); 或者 void f(X*);
• 如果你并不想改变被传递的对象，但该对象很大，那就按常量引用传递；例如 void f(const X&);
• 其它情况则应该按值传递；例如 void f(X);

原文地址：http://www.research.att.com/~bs/bs_faq2.html#call-by-reference

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4