Explore
For Enterprise
Join for Free
Log In

艺术与人文
商务
计算机科学
数据科学
信息技术
健康
数学和逻辑
个人发展
物理科学与工程
社会科学
语言学习
学位
证书

浏览 Coursera 的全部课程

浏览
搜索
企业版
登录
免费加入

3.1 C++ Classes & Object Orientation

Loading...

C++ For C Programmers, Part A

加州大学圣克鲁兹分校

4.4（617 个评分） | 93K 名学生已注册

本课程是面向有C语言经验的，并想要学习C++编程的程序员们。涉及到的例子和练习需要有对基础算法和面向对象软件的理解。

查看授课大纲

您将学习的技能

Graph Theory, C++11, C++, Graph Algorithms

审阅

4.4（617 个评分）

5 stars
402 ratings
4 stars
138 ratings
3 stars
31 ratings
2 stars
20 ratings
1 star
26 ratings

AK

Jul 04, 2017

I like Prof. Ira a lot and wish to see more courses from him! I wish I was his student at SC. Best Regards to him and the Coursera team for the great work.

PK

Jul 18, 2018

I really loved this course. It is really helpul for my programming aspect. I have managed to develop my logical abilty and this course really helped me.

从本节课中

Module 3

Point: Default constructor and initializing syntax. Conversion Constructors. Copy Constructor. List and dynamic memory allocation. Deep Copy.

3.1 C++ Classes & Object Orientation7:19

3.2 Point and its Constructor12:42

3.3 More Constructors18:22

3.4 Using Dijkstra's Algorithm14:22

3.5 The is-connected Algorithm12:05

3.6 Complex Aggregates - Lists6:53

3.8 Print() Chaining6:20

3.9 More Elaborate List3:43

3.10 Deep vs. Shallow Copy8:48

3.11 Destructor4:49

3.12 Dynamic Data Structures in STL7:50

教学方

Ira Pohl
Professor

脚本

[MUSIC]

Today, we're going to get deeper into the object oriented programming style.

So we're going to look at more C++ classes and

how that builds on in an object oriented manner.

We're going to look again, at constructors and

destructors which are these critical methods that both build and

deallocate the new extended data types.

And then we're going to discuss our next significant homework assignment and

that's a homework assignment based on graph theory.

So again, all of you came in having a background in

computer science roughly at a sophomore level at least and

you may well have already seen standard graph theory algorithm.

So this may be familiar to you.

In any case, I will review all that material.

So even if you have forgotten it or

haven't in the past had an adequate background,

we're going to really understand Dijkstra's shortest path algorithm and

that's going to be the basis for our second homework assignment.

Objects.

Objects could be anything.

So here in this little example, we're thinking of shapes.

Shapes could be boxes, polygons, text shapes.

There can be operations like delete on

them operations that involve counting the shapes.

And so if you wanted to build a windowing environment,

what would be our set of widgets?

What would be the operations?

What would the user expect, the user of this package of routines?

How would we properly design things and keep the internal details hidden away.

All of that is what you have to think about when you're

an object oriented C++ programmer.

Again, a best guideline to doing this thought

process is to know what happens in the language for native types.

So with native types, we have to fully understand what happens

when we declare something, even a simple object like an int.

What does it mean to say int i, j = 3?

Well, we typically do that inside block scope.

Block maybe inside the main function or

it maybe in the auxiliary file scope functions.

So we're declaring here, we're allocating.

We're initializing.

Now for a simple native type, all this happens automatically on the stack.

We have to replicate that for our user defined types for our objects.

And again, as we started with last time,

we saw we had a special method for doing this called a constructor.

So just for review purposes in the C language or in basic C++,

what is supposed to happen here where we have nested blocks?

So here's a a main.

We have two declarations, i is initialized the 9.

J has initialized the 3.

We're going to print what goes to screen.

So that's what we're expecting you to do.

This is going to be very similar to the kinds of exams that I give.

This is a question that I could readily put on are in our final exam.

And then secondarily, we have an internal block is not,

here's the internal block then the nested internal block.

Now, I actually would have preferred an indented style.

This is not, you should reformat that if you're going to try the code.

So that the internal block is indented.

So that you can visually.

That's again, a convention.

But it makes it more readable, you can visually see the inner block.

And so in the inner block, there's a redeclaration int i and

we're asking what that prints versus at the outer block.

And the answer is the inner block,

the outer block has 9 and 3.

But the inner block has what you might call i inner,

which was recalculated to be 5 and j was left.

J just got passed in, because there was no inner block j.

So that's really j outer.

And then over here, we have outer again.

And when we go to the outer block and

we print it, we see that value 9 was retained.

So that should all be in your knowledge base already.

From an allocation point of view, i and

j are placed on the stack.

Inner block.

I inner is on the stack.

I outer is hidden.

Then we have block exit.

I inner Is destroyed.

And then we return to the outer block and we have again,

i9 and j3 which are the outer block variables that are still on the stack.

探索我们的目录

免费加入并获得个性化推荐、更新和优惠。

Coursera 致力于普及全世界最好的教育，它与全球一流大学和机构合作提供在线课程。

© 2019 Coursera Inc. 保留所有权利。

通过 App Store 下载

通过 Google Play 获取

Coursera
关于
管理团队
工作机会
目录
证书
MasterTrack™ 证书
学位
企业版
政府版

社区
Learners
Partners
Developers
Beta Testers
Translators

连接
博客
Facebook
领英
Twitter
Instagram
YouTube
技术博客

更多
条款
隐私
帮助
内容访问
媒体
联系我们
目录
附属公司