Shadowing Practice: Stack Data Structure In STL | C++ Tutorial - Learn English Speaking with Video

בחר מצב תרגול

כל מצב פותח חדר תרגול במסך מלא.

199 משפטים

אם המשפטים קצרים או ארוכים מדי, לחץ על ערוך כדי להתאים אותם.

In this video, we're going to learn about the stack data structure class template that's built into the C++ standard template library.

So a data structure stores a collection of data and stacks are a type of data structure.

Stacks are very commonly used in practice, so they're included directly in the C++ standard template library.

Stacks are a last in first out data structure.

What

that means is the last element that's put into the data

structure is going to be the first element out of the data structure.

So a stack data structure works like a stack of plates or books.

For example, we could have a stack data structure to store integer values.

And when we insert elements onto the stack, we say that we push them onto the stack.

When we remove elements from the stack, we say that we pop them from the stack.

So for example, if we pushed the element 5 onto the stack, 5 would be here.

We could call this the bottom of the stack.

We could then push the element 7 onto the stack, and 7 would go here.

We would say that 7 is at the top of the stack.

Then we could push another element onto the stack.

So we could push 9 onto the stack.

9 would then be the new top of the stack.

Now if we popped an element off this stack, it's always going to be removed from the top of the stack.

So if we popped an element off this stack here it would be this element here that's popped

and then seven would become the new top of the stack

and we could keep popping elements from the stack

and eventually the stack would be empty where an empty stack

is a stack with no elements we would say this stack here has a size of two

because the stack has two elements and there's also typically an operation which allows us to view the top of the stack.

It's usually called peak.

In C++, it's called top.

So let's try out the stack data structure that's built into the C++ standard template library.

The first thing we'll do is include the stack library.

This will allow us to declare and use stack objects.

Then down here, we'll declare a stack object to store in values called numbers.

So this will declare a stack object to store in values called numbers.

Now initially this stack is going to be empty and it's going to have a size of zero.

Stack objects have size and empty methods

that we can use to check the size of a stack and to check whether it's empty or not.

So let's call those methods.

Here we'll output size colon

and then we'll call numbers .size where size is going to return the size of the stack

and we'll output that then we'll also call the empty method to check

if the stack is empty so

if numbers .empty is true then we'll output here stack is empty followed by an end line

so the empty method is going to return true if the stack is empty and false otherwise.

So right now, if we save compile and run the program, we'll get that the stack has a size of zero and that the stack is empty, both of which are correct.

So now let's push an element onto the stack.

We'll have here numbers .push and we'll push the value eight onto the stack.

Now, if we check the size of the stack, the size should now be one.

Let's try that we'll copy this and down here we'll paste it

and if we save compile and run the program now

we see the size is now one we could also check

if the stack is not empty so now we'll have if

not numbers dot empty is true so in other words if the empty function now returns false

then we'll output stack is not empty followed by an end line

and if we save compile

and run the program we'll now get stack is not empty

we can also retrieve the value at the top of the stack using the top method

so we could call here numbers dot top

and this is going to return the value that's at the top of the stack.

We'll output that.

We'll have here top colon and we'll output the value at the top of the stack followed by an end line.

And if we save compile and run the program, we'll now get the value at the top of the stack is eight.

And that makes sense because right now eight is the only thing on the stack.

We could try to push a few more values onto the stack

so right now we have eight at the bottom of the stack which is also the top of the stack.

We could push on, let's say, the value 9.

We'll have numbers .push and then 9.

So then at this point, 9 would become the new top of the stack and 8 would still be at the bottom of the stack.

We could also push on the value 5.

We could have numbers .push 5.

And then 5 would be at the top of the stack and the stack would now have a size of 3.

So let's output the size and top after performing these operations.

Down here, we'll output the top again with cout top and numbers .top.

We'll also output an endline for spacing and we'll also output the new size.

So we'll have cout and size colon and we'll have numbers .size to output the size followed by an end line.

And now if we save compile and run the program, we'll get that the new top of the stack is five and the new size of the stack is three,

both of which are correct.

So then we could also pop a value from the stack.

So for example, with this stack here, if we pop a value from the stack, it's going to be the element five that's removed from the stack.

so let's try that we'll use the pop method of the stack object to do that we'll have here numbers .pop

now this method is only going to remove the element at

the top of the stack it's not going to return it

so we'll output here the new top of the stack

and the new size of the stack we'll copy these and paste them after the pop.

So now if we save compile and run the program, we'll get that the new top of the stack is nine and the new size of the stack is two,

both of which are correct because here we have nine at the top of the stack

and the size of the stack is now two.

Now again, the pop method is not going to return the value that's removed from the stack.

So we're going to lose it if we don't save it.

So what we may want to do is save the value in a variable.

For example, we could have here int popped value is equal to,

and we'll call numbers .top to return the value that's currently at the top of the stack

and save it into this variable here.

Then we can pop the value, but we still have the value saved in this variable here.

So we could output that we could have cout

and let's say popped value colon

and we'll output the pop value followed by an inline and

if we save compile

and run the program we'll see the pop value is five

the previous top of the stack before we pop the value

off the stack now we can also use the swap method to swap the contents of two stacks.

100

So for example, let's declare another stack to store int values.

101

We'll have here stack int, and we'll call this stack other stack.

102

Then we'll push the value four onto the stack.

103

So we'll have other stack dot push four.

104

So this stack only has one value on the stack.

105

We could output the size of the stack here.

106

We could have cout

107

and then other stack size colon we'll output the size of the other stack

108

and we'll also output an end line as well.

109

So now if we save compile and run the program, we'll get here that this other stack has a size of one.

110

We can now swap this stack with our original stack numbers.

111

So we could have other stack and then dot swap to call the swap method and we'll pass it numbers.

112

And this will swap the contents of the two stacks.

113

So other stack should now have the two values nine and eight and numbers should now have the one value four.

114

Let's output the size of the stacks to confirm this.

115

So we'll output here an end line and then we'll output the size of other stack.

116

So we'll copy this and paste it here

117

and we'll also put the size of the number stack with numbers size colon

118

and we'll output numbers dot size

119

and then we'll output end lines as well one after outputting the other stack size

120

and another after outputting the number stack size so now if we save compile and run the program,

121

we'll see the other stack size is two and the number stack size is one.

122

So we can tell these stacks have been swapped.

123

Now the type int is a primitive type in C++.

124

We can also push objects onto a stack using the push method.

125

If we use the push method to push objects onto the stack, a copy of the object is going to be created.

126

There's also a method called in place.

127

The in place method will actually forward its arguments to the constructor of the object

128

and create an object for the purposes of the stack.

129

Let me show you the difference.

130

The first thing we'll do is define our own class called employee.

131

So up here we'll define a class called employee and this is going to be a pretty simple class.

132

We'll have one public member variable called days.

133

The constructor for employee objects

134

is going to accept an int as an argument called days

135

and we'll set the days member variable to the days value that's provided.

136

We'll also output in this constructor constructor called

137

and the number of days just

138

so we can verify the constructor has been called followed by

139

an inline we'll also create what's called a copy constructor the

140

copy constructor is called to create a copy of the object

141

its parameter is going to be a reference parameter of the same type of this object here employee

142

so we'll have const employee and then end employee and we'll output here that the copy constructor has been called.

143

So we'll have copy constructor called and we'll output the days in this object here followed by an end line.

144

And we'll also set this copy objects days to match the days of the object that it's copying.

145

So we're making a copy of this object here.

146

So we're going to take its days value and set the days member variable of this employee object to that value.

147

So then down here, we'll declare a stack to store employee objects.

148

We'll have stack employee, and we'll call this stack to store employee objects, employee underscore stack.

149

We'll create an employee object called Joe.

150

We'll have employee Joe, and we'll have 10, and maybe 10 is the number of days that Joe worked, then we'll push Joe onto the stack.

151

So we'll have employee stack dot push Joe.

152

So now if we save compile and run the program,

153

we'll get this constructor called 10 and then again, copy constructor called 10.

154

So what's happened here is two objects have been made.

155

Originally, we made the Joe object here.

156

then when we push Joe onto the stack, a copy of the Joe object is made.

157

So be aware of the fact that's how it works.

158

Now we could also use a method called emplace,

159

and the emplace method will actually forward its arguments to the constructor of this type of object that the stack is storing, in this case here, employee.

160

And it's going to create an object that's going to exist on the stack.

161

So if we have here employee stack and we call the emplace method

162

and we pass it let's say 20 what's going to happen

163

is 20 is going to be passed to an employee object constructor

164

and the employee object that's created is going to be pushed onto the stack.

165

So if we save compile and run the program notice this this time we only get constructor called 20

166

No copy constructor is called.

167

So in the case of Joe, the Joe object was created, and when we push Joe onto the stack, a copy of that object was created.

168

Here, that's not occurring.

169

Here, what's happening is the object is being created and placed directly on the stack.

170

Now, notably, if we call the top method to retrieve the element at the top of the stack, and we assign the result to an employee variable,

171

at that point the copy constructor is going to be called.

172

So if we had let's say employee and we'll have maybe top employee is equal to employee stack dot top.

173

At this point the copy constructor will be called to make a copy of that employee object.

174

So if we save compile

175

and run the program we'll find now a copy has been made of that object at the top of the stack.

176

Now when we pop an object from the stack, the destructor for that object is going to be called.

177

So we could have a destructor in our employee class.

178

We'll have here tilde employee.

179

And again, we'll make a very simple destructor.

180

What we'll do is just output that the destructor has been called.

181

So we'll have cout and then destructor.

182

and called and we'll put the days followed by an inline.

183

So now down here, if we pop the top element from the stack, we'll see that destructor is called.

184

So what we'll have is employee and then stack and we'll have dot pop to pop the top element from the stack.

185

I'm actually going to comment out this line here and this line here and this line here.

186

So we can just focus on this one element at the top of the stack.

187

So right now, if we save compile and run the program, we'll see here that we get destructor called 20.

188

So when we pop that object from the stack, the destructor was called.

189

So in C++, the implementations of different data structures like stacks and queues that come with the standard template library are called containers.

190

In particular, the stack container is called a container adapter.

191

It's called a container adapter because underlying a stack object is going to be a container object of a different type.

192

So there might be something like a vector

193

or a DQ container object that's really behind the scenes where

194

the stack object is kind of like a limited interface

195

that allows us to access that other object in a limited way that conforms to the rules of a stack, which is important.

196

The last in first out behavior of stack data structure elements is what makes stacks useful in certain scenarios like parsing.

197

So this is how we can use stacks in the C++ standard template library.

198

Check out portfoliocourses .com where we'll help you build a portfolio that will impress employers.

199

Thank you.

הורד אפליקציה

כל מה שאתה צריך כדי לדבר בשטף

הגיית AIציון לכל משפט

תרגול IPAשלוט בכל צליל

אוצר מיליםבנה את מאגר המילים שלך

משחק אוצר מיליםלמד תוך כדי משחק

סרוק QR

Download on theApp Store Get it onGoogle Play

FOR YOU

המלץ על סרטון

31 משפטים

אוצר מילים והערות הגייה לשיעור הזה

שיעור הדיבור הזה ברמה C1 מבוסס על הסרטון “Stack Data Structure In STL”. המילים שחוזרות הכי הרבה: stack, object, size, value, output. בסרטון הזה יש 199 משפטים ו-2623 מילים לתרגול Shadowing. הדיבור נמשך 16:58. הדובר מדבר בקצב טבעי של כ-155 מילים בדקה, קרוב לשיחה יומיומית. 85% מהמילים נמצאות בין 3,000 המילים הנפוצות ביותר באנגלית; כדאי ללמוד את השאר לפני שמתחילים.

אוצר מילים מרכזי בסרטון הזה

10 המילים המתקדמות ביותר בסרטון, עם ההגייה והמשמעות שלהן:

מילה	הגייה	משמעות
stack שם עצם	/stæk/	ערמה
colon שם עצם	/ˈkoʊ.lən/	נקודתיים
template שם עצם	/ˈtɛm.plɪt/	תַּבְנִית, שַׁבְּלוֹנָה
container שם עצם	/kənˈteɪ.nəɹ/	מיכל
pasta שם עצם	/ˈpɑ.stə/	פַּסְטָה
integer שם עצם	/ˈɪn.tɪ.d͡ʒə(ɹ)/	שלם, מספר שלם
queue שם עצם	/kju/	תּוֹר
verify פועל	/ˈvɛɹɪfaɪ/	וידא
vector שם עצם	/ˈvɛktɚ/	וקטור
insert פועל	/ɪnˈsɝt/	לְהַכְנִיס

Phrasal verbs שתשמעו

מילה	משמעות
check out פועל	בדק

משפטים שכדאי לחזור עליהם

משפטים קצרים ושלמים מהסרטון שאפשר להשתמש בהם בשיחה יומיומית:

Then we'll push the value four onto the stack.
We'll have one public member variable called days.
We'll have here tilde employee.

דקדוק בסרטון הזה

המבנים שהדובר משתמש בהם הכי הרבה, עם המילים המדויקות מהסרטון:

מבנה	בסרטון
סביל (Passive voice) be + past participle — הדגש הוא על מה שקורה, לא על מי שעושה את הפעולה	be removed · have been swapped · be created
הווה מושלם (Present perfect) have/has + past participle — פעולה שקרתה בעבר ועדיין יש לה חשיבות או השפעה עכשיו	have been swapped · has been called · have been made
משפטי זיקה (Relative clauses) who / which + clause — מידע נוסף על אדם או דבר	stack which is · stack, which is

הגייה ששווה לשים לב אליה

הדובר משתמש ב-88 קיצורים וצורות מקוצרות, כמו we'll, we're, don't. אמרו אותם בצורה הקצרה, כפי שאתם שומעים אותם.

צלילים שדוברי עברית מתקשים בהם:

/æ/ — פתוח יותר מה-“אֶ” העברית, לא כמו “a” ב-“cup”: stack /stæk/, parameter /pəˈɹæm.ə.tɚ/, adapter /əˈdæptəɹ/
/r/ — הלשון לא נוגעת בשום מקום, לא ה-“ר” הגרונית: container /kənˈteɪ.nəɹ/, parameter /pəˈɹæm.ə.tɚ/, adapter /əˈdæptəɹ/, retrieve /ɹɪˈtɹiːv/, integer /ˈɪn.tɪ.d͡ʒə(ɹ)/
עיצור קולי בסוף מילה — /b/, /d/, /g/, /z/, /v/ בלי להפוך אותם לאטומים: retrieve /ɹɪˈtɹiːv/, primitive /ˈpɹɪmɪtɪv/

איך לתרגל עם הסרטון הזה

הקשיבו לכל הסרטון פעם אחת בלי לדבר, ורשמו את המילים שאתם לא מכירים.
התחילו במהירות 0.75×, תרגלו Shadowing משפט אחר משפט, וחזרו למהירות רגילה כשזה מרגיש קל.
הקליטו את עצמכם והשוו למקור, תוך תשומת לב למילים כמו stack, colon, template.

מהי טכניקת השאדואינג?

שאדואינג היא טכניקת למידת שפה מבוססת מדע שפותחה במקור להכשרת מתורגמנים מקצועיים ופופולרית על ידי הפוליגלוט ד"ר אלכסנדר ארגואלס. השיטה פשוטה אך עוצמתית: אתה מקשיב לאודיו באנגלית ילידית וחוזר עליו בקול רם מיד — כמו צל העוקב אחרי הדובר עם עיכוב של 1–2 שניות בלבד. בניגוד להאזנה פסיבית או תרגילי דקדוק, שאדואינג מכריח את המוח והשרירים בפה לעבד ולשחזר דפוסי דיבור אמיתיים בו זמנית. מחקרים מראים שזה משפר משמעותית את דיוק ההגייה, האינטונציה, הקצב, הדיבור המחובר, הבנת השמיעה ושטף הדיבור — מה שהופך אותו לאחת השיטות היעילות ביותר להכנה לIELTS Speaking ולתקשורת באנגלית בעולם האמיתי.

טכניקת Shadowing: קרא את המדריך המלא שלב אחר שלב →

Shadowing Practice: Stack Data Structure In STL | C++ Tutorial - Learn English Speaking with Video

בחר מצב תרגול

הורד אפליקציה

Heaps in 3 minutes — Intro

SDLC Vs STLC: Software Development Life Cycle and Software Testing Life Cycle

Cell Biology | Cell Structure & Function

#62 Python Tutorial for Beginners | Generators

What is Docker? Docker container concept explained || Docker Tutorial 1

► 2. СВОЙСТВА МАССИВОВ. Функции автозаполнения | Курс по Numpy.

7 Cấp Độ Toán Học: Bạn Đang Ở Đâu?

Handy CSS layout patterns, and fun ways to elevate them

You are wasting memory

000 - STM32F1 Tutorial Introduction Video

🚫 Java Deadlock Explained: Why Your Code is Stuck 😱 (Beginners Must Watch!)

Data Analysis Essentials in Excel