12.2 什么是文化，我们为什么要关注 What Is Culture And Why Do We Care | Model Thinking | Coursera | MOOC学院 果壳网旗下慕课学习社区
12.2 什么是文化，我们为什么要关注 What Is Culture And Why Do We Care第6周
文化的不同定义：泰勒(Tylor，1871，现代文化和人类学之父)曾说：文化是一个包含知识、信仰、艺术、法律、道德和传统的复杂集合体（ complex whole which includes knowledge, belief, art, law, morals, customs ）。他把文化视为一种复合体，是一种宽泛的定义。 法兰兹·博厄斯(Franz Boas，1911)对其定义进行了扩展，他认为文化是精神和生理反应的结合（totality of mental and physical reactions and activities that characterize behavioral responses to environment, others, and to himself.）博厄斯是第一个想到这些反应存在某种一致性(consistency)的人，这种一致性可能是环境所赋予的，也可能是社会生活中自然构建的，重点在于人们的举止行为之中有某些一致性。 卡文·特里林在1955年这样写道：“当我们从文化层面出发抽象地看待人类，我们会情不自禁地为眼前所见而深深感动，会情不自禁地震撼于某些神秘的力量——某种具有创造性的力量，其存在超越了任何所能观察到的具体的行为、习惯或特性。为了让生活具有一致性，为了对抗来自外在和内心世界的恐惧，为了建立仪式和艺术体系，虔诚和责任使得集体和个体的生活成为可能——这些都是文化，因此研究这些组成了文化的各项主体难免被感动。（When we look at a people in the degree of abstraction which the idea of culture implies, we cannot but be touched and impressed by what we see, we cannot help but be awed by something mysterious at work, some creative power which seems to transcend any particular act or habit or quality that may be observed. To make a coherent life, to confront the terrors of the outer and the inner world, to establish the ritual and art, the pieties and duties which make possible the life of the group and the individual – these are culture, and to contemplate these various enterprises which constitute a culture is inevitably moving.）“使集体和个体的生活成为可能”这个概念意味着：为了让群体和个体运作起来，它们之间必须有某些相似点，我们首先必须认同或协调一系列特定的行为、理解、道德、法律、传统，才能够去对抗生命里那些来自内在或外在的恐惧。 文化现象最有趣的就是：不同文化之间有很多不同之处。并不是全人类的行为准则都相同，不同的公司和组织也有着不同的文化。社会学家Joe Henrich, Sam Bowles, Jean Ensminger等人做了一个实验，在各种不同的社会里玩同一个名叫“最后通牒”的游戏：给玩家1十块钱，然后他会被要求分一部分钱给玩家2，可以是5块、2块或者2分钱；玩家2可以选择接受或是拒绝，如果玩家2接受那么他们就分钱成功，如果拒绝那么两人都分文不得。所以玩家1要做的就是在玩家2能够接受的情况下，尽可能地少分出一点钱，好让自己的利益最大化。在各种不同的文化、不同的群体里，人们做出的选择不一样：印尼的一个以协作捕鲸为生的部族Lamalera会给另一人5.7元等多于一半的数值；而亚马逊地区的Machigenga部落只愿给另一个人2.6等差不多四分之一左右的数值。去不同的地方进行重复实验并观察实验结果是否不同，将两个群体间的巨大差异(输入)和他们愿意分给别人的钱的数量（输出）视为他们的文化方程（算法），这就是社会科学家用来衡量文化差异的方法之一。另一种考察文化差异的方法是调查研究，教授的同事Ron Inglehart花费数十年之力对世界各地的人进行“世界性价值观调查(world values survey)”，然后用排名因子对结果进行整理，绘制了下图：他发现，仅仅通过两个维度的标准就能区分绝大部分的文化：第一个维度是“生存/自我表现”，在横坐标轴的左侧表示“生存导向”，即人们每天为了事物而奔波；横坐标轴右侧则更有自我表现欲，人们更关心自己的发型之类的外部表现。第二个维度是“传统/世俗”，纵坐标轴的下方更为传统，比如信仰宗教等等；上方更为世俗、理性。把参加调查的所有国家的数据用因子分析法(factor analysis)进行坐标化，会发现这个文化地图似乎是按照地理划分：欧洲新教国家更有自我表现欲、更世俗（右上）；伊斯兰和非洲国家宗教信仰强烈且以生存为目的（左下）；而儒家国家属于“生存导向-世俗型”（左上）；拉丁美洲则属于“自我表现-宗教型”（右下）；欧洲天主教国家在图上的正中间。这种方法问卷+因子分析的方法确实能帮助人们理解这个世界，通过这个二维坐标系将各国价值观图像化。但是要注意，图上的点代表的是国家整体，并不是这个国家所有人都具有完全相同的价值观，比如瑞典或津巴布韦所代表的那个点不仅仅是一个点，而代表了生活在那的所有人：瑞典的个体分布：津巴布韦的个体分布：可以看到瑞典和津巴布韦的价值观重叠很少，所以瑞典的人和津巴布韦的人之间明显是有区别的；但是瑞典人与瑞典人之间、津巴布韦人与津巴布韦人之间同样也是有区别的。 商业专家Geert Hofstede也用坐标轴划分文化，他采用五个维度，包括权力距离(power distance)(你愿意接受多大程度的地位不平等？)、回避不确定性的倾向(Uncertainty avoidance)、个人主义和集体主义(Individualism /Collectivism)、男子气概（Masculinity/Feminity ）、儒家/物力论倾向(Confucianism/Dynamism)（取决于你的远见程度）。美国：法国：可见法国人比美国人更不愿接受地位不平等，更倾向于规避不确定性。萨瓦尔多和朝鲜的对比：他们得分差不多但实际差异很大，所以只用少数几种标准还是不足以捕捉所有的文化差异的，单一的定义也不能概括丰富多彩的文化。 为什么要研究文化：Ken Arrow(诺贝尔奖经济学家)说：如果仔细思考经济、政治、社会是如何运作的，就会发现文化是沟通、调节这些社会交流的桥梁。正如Arrow所说，其实很多情况下经济落后都是缺乏相互信任造成的，所以在文化中存在不同程度的信任，而不同的信赖程度又决定了政治、经济、社会、宗教机构的运行情况以及这些机构满足公民需要的能力，所以人群表现主要取决于信任，而信任正是文化的一个重要组成部分。但信任也存在问题，即难以量化：诺贝尔经济学奖得主Bob Solow完全认同这些有关信任和社会资本之类的概念，这些东西都对文化很重要，但同时他认为我们需要能够进行量化的因素，而不是单纯的比喻。我们建模是为了能够量化和理解事物，以便我们知道事物到底如何运作。Inglehart和Hofstede所做的就是量化文化间的差别：用问卷提问的形式来量化。比如：您是否有以下行为：是否曾向政府要求应得的利益？是否在使用公共交通时逃过票？是否偷税漏税？如果捡到钱您会占为己有吗？不小心撞坏了别人停着的车会主动赔偿吗？……通过问这类问题，帮助你衡量人们有多少信任感。Ron设计则是“总体来说您认为他人值得信任吗？”这样宽泛的问题。不同的国家给出的答案有巨大的不同：比如在瑞典（在Inglehart的地图的右上方），70%的人说“我认为可以信任他人”，意大利只有33%，土耳其则只有10%。人们之间的信任会影响经济运作，所以社会和经济的运行状况在高信任度的国家里更好。信任度和GDP之间有相关性：图上横轴是信任他人的人的人口比例，纵轴是GDP中位数(median)，可以看见明显的上升趋势。虽然也可能是高GDP才让人们建立起信任感，但不可否认高信任度与高GDP相关联，因此高GDP的国家同时也是高信任度的国家，这是为什么文化值得我们研究的原因之一。问一下what for 和why都是为什么,有什么区别?_百度作业帮
问一下what for 和why都是为什么,有什么区别?
what for :表目的,表用途,一般翻译成"用来做什么" why:表原因,一般翻译成"为什么",why一般都要 用because来回答 eg.A:This is a knife.B:What for?(=What is this for?这是用来干啥的) A:It's used for cutting something.A:Why do you come here so late?B:Because my watch is broken.还有就是what for 更口语一点
what for 是“做某事是为了什么”的意思why
是指某个问题的原因
why 一般用于直接提问别人为什么，而what for 是谈话的一方向一方提出的反问或what for 是“做某事是为了什么”的意思 why 是指某个问题的原因
why 一般用于直接提问别人为什么，而what for 是谈话的一方向一方提出的反问。这是我个人的理解。
您可能关注的推广回答者：家用投影机的“What、Why、How”第1页：前言第2页：投影机能为我们带来什么第3页：为什么是投影机第4页：我们要为投影机付出怎样的代价第5页：什么投影机适合家用第6页：家用投影机有哪些种类第7页：搭建家庭影院技巧第8页：投影幕的选择明白了投影机能为我们带来什么，可能你还有些不理解的是，为什么只有投影机能承担这个角色。平板电视、背投电视难道不可以吗？首先一个制约因素就是画面尺寸。追求影院一样的包围感和竞技场的现场感，画面尺寸一定要足够大。那么究竟多大才适合呢？在普通人的观念里，在两米的距离观看50英寸画面是不是有些过分？但这是追求现场感的基本要求。研究表明，要实现影院一般的大画面效果，屏幕视角跨度至少应该达到30度。举例来说，当你在50公分距离上观看12英寸笔记本电脑画面时，恐怕没有觉得画面有多么宽阔，但是此时屏幕视角跨度就是30度左右。所以说这一要求对于影院效果来说其实并不算苛刻。但是如果用它来衡量家里的播放设备就会发现，能达到这一标准而且价格还能接受的恐怕也只有投影机了。
要获得电影院一样的宽银幕效果，屏幕的视角跨度至少要达到30度，在普通的客厅里3-4米的距离上，需要80-100英寸的画面，只有投影机能够在合理的价位上得到这么大的画面。一般家居客厅的观看距离在三至四米左右，所以需要屏幕尺寸达到80-100英寸。如果是平板电视，无论是采用液晶还是等离子技术，随着屏幕尺寸的增大价格会急剧上升，这么大尺寸的价格会超出普通人的承受能力，而且其重量、体积、功耗、热量和安装难度也都会达到惊人的程度。背投电视是一个看起来价廉物美的选择，但其实背投电视就是内置投影机并集成了屏幕而已。大多数背投电视的尺寸也在40-60英寸之间，如果观看距离小于三米还可以接受。其实从名称上就可以看出，背投电视的角色本质上就是大屏幕平板电视相对廉价的替代品。大画面是投影机的最大特点。投影机获得更大的画面不需要增加投入，只需要把机器挪得距离屏幕远一些就可以了。如今一台高清720p投影机的价格已经不到一万元了，如果你房间足够大，200英寸画面也不成问题。从“画面尺寸价格比”角度看，投影机的优势的确是无可比拟的。尽管投影屏幕随尺寸增加也会带来一些成本上升，但是和平板电视相比就微乎其微了。所以在家里获得大画面最现实可行的方法非投影机莫属。实际上，对于日渐普及的高清信号源来说，投影机才是高清的最佳代言人。例如，尽管平板电视很多都能达到1080p高清分辨率，但是这更多是数字上的意义，对于实际应用而言并没有什么大的差异。在三米的距离上，普通人想要凭借肉眼分辨出46英寸720p分辨率和1080p分辨率的平板电视在画面清晰度上的差别，几乎是不可能的。甚至你会发现高质量的DVD9电影和高清画面的差别也并不明显。毕竟我们肉眼的分辨力是有限的，距离较远时画面的像素尺寸小于我们肉眼的分辨能力，这时不同分辨率画面之间的差别对我们来说就没有意义了。所以只有画面尺寸足够大，高清信号源的优越性才会凸显出来。在一些高档电影院中采用的专业投影机甚至装备了4K芯片（），提供超过家用高清清晰度四倍的画面。所以，从现实意义上讲也只有投影机才能成为高清时代的最佳代言人。文章列表
[an error occurred while processing this directive]Smart Pointers - What, Why, Which?
Smart Pointers - What, Why, Which?
Translations:
Smart pointers are objects that look and feel like pointers, but are
smarter. What does this mean?
To look and feel like pointers, smart pointers need to
have the same interface that pointers do: they need to support pointer
operations like dereferencing (operator *) and indirection
(operator -&). An object that looks and feels like something else is
called a proxy object, or just proxy.
and its many uses are described in the books
To be smarter than regular pointers, smart pointers need to do
things that regular pointers don't. What could these things be?
Probably the most common bugs in C++ (and C) are related to pointers
and memory management: dangling pointers, memory leaks, allocation
failures and other joys. Having a smart pointer take care of these
things can save a lot of aspirin...
The simplest example of a smart pointer is auto_ptr, which is
included in the standard C++ library. You can find it in the header
&memory&, or take a look at
. Here is part of auto_ptr's
implementation, to illustrate what it does:
template &class T& class auto_ptr
explicit auto_ptr(T* p = 0) : ptr(p) {}
~auto_ptr()
T& operator*()
{return *}
T* operator-&()
As you can see, auto_ptr is a simple wrapper around a regular pointer.
It forwards all meaningful operations to this pointer (dereferencing
and indirection). Its smartness in the destructor: the destructor takes
care of deleting the pointer.
For the user of auto_ptr, this means that instead of writing:
void foo()
MyClass* p(new MyClass);
p-&DoSomething();
You can write:
void foo()
auto_ptr&MyClass& p(new MyClass);
p-&DoSomething();
And trust p to cleanup after itself.
What does this buy you? See the next section.
Obviously, different smart pointers offer different reasons for use.
Here are some common reasons for using smart pointers in C++.
Automatic cleanup.
As the code above illustrates, using smart pointers that clean after
themselves can save a few lines of code. The importance here is not so
much in the keystrokes saved, but in reducing the probability for bugs:
you don't need to remember to free the pointer, and so there is no
chance you will forget about it.
Automatic initialization.
Another nice thing is that you don't need to initialize the auto_ptr to
NULL, since the default constructor does that for you. This is one less
thing for the programmer to forget.
Dangling pointers.
A common pitfall of regular pointers is the dangling pointer: a pointer
that points to an object that is already deleted. The following code
illustrates this situation:
MyClass* p(new MyClass);
MyClass* q =
p-&DoSomething();
// Watch out! p is now dangling!
// p is no longer dangling
q-&DoSomething();
// Ouch! q is still dangling!
For auto_ptr, this is solved by setting its pointer to NULL when it is copied:
template &class T&
auto_ptr&T&& auto_ptr&T&::operator=(auto_ptr&T&& rhs)
if (this != &rhs) {
ptr = rhs.
rhs.ptr = NULL;
return *this;
Other smart pointers may do other things when they are copied. Here are
some possible strategies for handling the statement q&=&p, where p and
q are smart pointers:
Create a new copy
of the object pointed by p, and have q point to this copy. This
strategy is implemented in .
Ownership transfer:
Let both p and q point to the same object, but transfer the
responsibility for cleaning up (&ownership&) from p to q.
This strategy is implemented in .
Reference counting:
Maintain a count of the smart pointers that point to the same
object, and delete the object when this count becomes zero. So the
statement q&=&p causes the count of the object pointed by p to
increase by one. This strategy is implemented in
. Scott Meyers offers
in his book
Reference linking:
The same as reference counting, only instead of a count, maintain a
circular doubly linked list of all smart pointers that point to the
same object. This strategy is implemented in
Copy on write:
Use reference counting or linking as long as the pointed object is
not modified. When it is about to be modified, copy it and modify
the copy. This strategy is implemented in
All these techniques help in the battle against dangling pointers. Each
has each own benefits and liabilities. The
section of
this article discusses the suitability of different smart pointers
for various situations.
Let's take another look at this simple example:
void foo()
MyClass* p(new MyClass);
p-&DoSomething();
What happens if DoSomething() throws an exception? All the lines after
it will not get executed and p will never get deleted! If we're lucky,
this leads only to memory leaks. However, MyClass may free some other
resources in its destructor (file handles, threads, transactions, COM
references, mutexes) and so not calling it my cause severe resource
If we use a smart pointer, however, p will be cleaned up whenever it
gets out of scope, whether it was during the normal path of execution
or during the stack unwinding caused by throwing an exception.
But isn't it possible to write exception safe code with regular
pointers? Sure, but it is so painful that I doubt anyone actually does
this when there is an alternative. Here is what you would do in this
simple case:
void foo()
p = new MyClass;
p-&DoSomething();
catch (...) {
Now imagine what would happen if we had some if's and for's
in there...
Since C++ does not provide automatic garbage collection like some other
languages, smart pointers can be used for that purpose. The simplest
garbage collection scheme is reference counting or reference linking,
but it is quite possible to implement more sophisticated garbage
collection schemes with smart pointers. For more information see
Smart pointers can be used to make more efficient use of available
memory and to shorten allocation and deallocation time.
A common strategy for using memory more efficiently is copy on write
(COW). This means that the same object is shared by many COW pointers
as long as it is only read and not modified. When some part of the
program tries to modify the object (&write&), the COW pointer
creates a new copy of the object and modifies this copy instead of the
original object. The standard string class is commonly implemented
using COW semantics (see the &string& header).
string s(&Hello&);
string t =
// t and s point to the same buffer of characters
t += & there!&;
// a new buffer is allocated for t before
// appending & there!&, so s is unchanged.
Optimized allocation schemes are possible when you can make some
assumptions about the objects to be allocated or the operating
environment. For example, you may know that all the objects will have
the same size, or that they will all live in a single thread. Although
it is possible to implement optimized allocation schemes using
class-specific new and delete operators, smart pointers give you the
freedom to choose whether to use the optimized scheme for each object,
instead of having the scheme set for all objects of a class. It is
therefore possible to match the allocation scheme to different
operating environments and applications, without modifying the code for
the entire class.
The C++ standard library includes a set of containers and algorithms
known as the standard template library (STL).
to be generic (can be used with any kind of object)
and efficient (does not incur time overhead compared to
alternatives). To achieve these two design goals, STL containers store
their objects by value. This means that if you have an STL container
that stores objects of class Base, it cannot store of objects of
classes derived from Base.
class Base { /*...*/ };
class Derived : public Base { /*...*/ };
vector&Base&
v.push_back(b); // OK
v.push_back(d); // error
What can you do if you need a collection of objects from different
classes? The simplest solution is to have a collection of pointers:
vector&Base*&
v.push_back(new Base);
v.push_back(new Derived);
// cleanup:
for (vector&Base*&::iterator i = v.begin(); i != v.end(); ++i)
delete *i;
The problem with this solution is that after you're done with the
container, you need to manually cleanup the objects stored in it. This
is both error prone and not exception safe.
Smart pointers are a possible solution, as illustrated below. (An
alternative solution is a smart container, like the one implemented in
vector& linked_ptr&Base& &
v.push_back(new Base);
v.push_back(new Derived);
// cleanup is automatic
Since the smart pointer automatically cleans up after itself, there is
no need to manually delete the pointed objects.
Note: STL containers may copy and delete their elements behind the
scenes (for example, when they resize themselves). Therefore, all
copies of an element must be equivalent, or the wrong copy may be the
one to survive all this copying and deleting. This means that some
smart pointers cannot be used within STL containers, specifically the
standard auto_ptr and any ownership-transferring pointer. For more info
about this issue, see
Are you confused enough? Well, this summary should help.
The standard auto_ptr is the simplest smart pointer, and it is also,
well, standard. If there are no special requirements, you should use
it. For local variables, it is usually the right choice.
Although you can use auto_ptr as a class member (and save yourself the
trouble of freeing objects in the destructor), copying one object to
another will nullify the pointer, as illustrated Below.
class MyClass
auto_ptr&int&
// do some meaningful things with x
MyClass y = // x.p now has a NULL pointer
Using a copied pointer instead of auto_ptr solves this problem: the
copied object (y) gets a new copy of the member.
Note that using a reference counted or reference linked pointer
means that if y changes the member, this change will also affect x!
Therefore, if you want to save memory, you should use a COW pointer and
not a simple reference counted/linked pointer.
As explained above, using garbage-collected pointers with STL
containers lets you store objects from different classes in the same
container.
It is important to consider the characteristics of the specific
garbage collection scheme used. Specifically, reference
counting/linking can leak in the case of circular references (i.e.,
when the pointed object itself contains a counted pointer, which points
to an object that contains the original counted pointer). Its
advantage over other schemes is that it is both simple to implement and
deterministic. The deterministic behavior may be important in some real
time systems, where you cannot allow the system to suddenly wait while
the garbage collector performs its housekeeping duties.
Generally speaking, there are two ways to implement reference
counting: intrusive and non-intrusive. Intrusive means that the pointed
object itself contains the count. Therefore, you cannot use intrusive
reference counting with 3-rd party classes that do not already have
this feature. You can, however, derive a new class from the 3-rd party
class and add the count to it. Non-intrusive reference counting
requires an allocation of a count for each counted object. The
is an example of
non-intrusive reference counting.
Reference linking does not require any changes to be made to the
pointed objects, nor does it require any additional allocations. A
reference linked pointer takes a little more space than a reference
counted pointer - just enough to store one or two more pointers.
Both reference counting and reference linking require using locks if
the pointers are used by more than one thread of execution.
Sometimes, you want to receive a pointer as a function argument, but
keep the ownership of this pointer (i.e. the control over its lifetime)
to yourself. One way to do this is to use consistent naming-conventions
for such cases.
recommends using
&adopt& to mark that a function adopts ownership of a pointer.
Using an owned pointer as the function argument is an explicit
statement that the function is taking ownership of the pointer.
If you have objects that take a lot of space, you can save some of this
space by using COW pointers. This way, an object will be copied only
when necessary, and shared otherwise. The sharing is implemented using
some garbage collection scheme, like reference counting or linking.
For this:Use that:
Local variablesauto_ptr
Class membersCopied pointer
STL ContainersGarbage collected pointer (e.g. reference counting/linking)
Explicit ownership transferOwned pointer
Big objectsCopy on write
Smart pointers are useful tools for writing safe and efficient code in
C++. Like any tool, they should be used with appropriate care, thought
and knowledge. For a comprehensive and in depth analysis of the issues concerning
smart pointers, I recommend reading Andrei Alexandrescu's
in his book
Feel free to use
in your code.
libraries include some
smart pointers, which are more rigorously tested and actively maintained.
Do try them first, if they are appropriate for your needs.
Copyright 1999 by Yonat Sharon