Some students come to CS field but they have no idea about any programming language. Either they will have the background of engineering or medical. But still they want to make CS their field. What technique should be applied on them to take start, clear their initial concepts and make ready them how to code any program?
There are many ways to do this, they basically rely on the "culture" of students and the purpose that they should learn. C++ is a multiple model and not "pure" in any of them, so... Teaching language and realism is a process: start with some courses before the process: Make them know about the two, compilers, etc. do not go into detail, but tell the path to learn. Avoid the IDE: Use the command-line editor. You can insert the IDE later. But always give a wide look. Variables, and jobs must run ads together. Study Module C++ and indicators "problem combo", consider: string "base type", with Device: Table, Composite: Products and Model style: Map. Presenting the template as soon as possible, and teaching the context recursion. Also show recursion in specialization. Introducing the concept of "recollected" "Position indicator".
While I would suggest a different language for beginners, I'll take it as given here that the students need to learn C++ and not just programming for general use.
In that case, teach them Modern C++. That means C++ versions 14 and 17 and don't bother with anything earlier. To do this find a good book that focuses on those versions (or later if you are reading this in the future) and has been developed by someone who has good knowledge of pedagogy as well as the language. There are a couple of books available on Amazon that meet this criteria.
Note that you give up nothing by starting with the current version. The book will still cover the low level details that were inherited from C and that are still useful. You won't spend time trying to learn the things that have become obsolete for modern software development.
But, the important point is that a modern language comes with a set of idioms that enable its proper use. A language is not just a collection of features that you combine arbitrarily. It was designed with a vision.
So, once you get beyond trivial programs, you want to learn the current idiomatic usage of the language (whatever it is) along with the lower level details. In particular, you don't want to spend time on the idiomatic usage of an earlier version of the language once they have become obsolete.
I will also note that programming in a language requires the programmer to adopt some mental model. If a language is well designed, then it is possible to program completely within that model without worrying about how that model is implemented in some lower level model. That is to say, the model will be both consistent and complete. So, a book with good pedagogy will emphasize how you use that model to create useful artifacts.
The advantage of Modern C++ is that many of the pitfalls of earlier versions (and especially those of C) have been removed through the use of standard libraries. Lots of the kinds of errors that seem invariably to creep into commercial software don't occur at all (and so fewer viruses,...) if the programmer understands the libraries and the proper idiomatic use.
There is no need to take an historical approach to computing, starting with machine level programming and working UP to some higher level. That was my approach, actually, since I grew up with that history and have been programming for over 45 years. I didn't then use the languages that I use today since they didn't exist, not because it was better, in some way, for me to use primitive languages first.
Note that if a language does not provide a complete and consistent abstraction model for programming (if it isn't Turing Complete) then you would have to try to understand its features in terms of some lower level implementation mode. Otherwise you can learn the language directly and understand how the parts fit together idiomatically to write any program using a single mental model.
If you, as an individual want to learn everything bottom up, then go ahead. But if you are a teacher, I suggest that you don't impose that way of learning on your students. It is inefficient and unnecessary.
Once the students learn to program at a given (complete and consistent) level of abstraction they can then learn about how things are built or use them to build higher level abstractions.
If I had a choice of first teaching language today, it would probably be either Haskell (functional) or Scala (Object oriented). Both of these offer complete and consistent mental (abstraction) models as well as rich libraries. The teaching method would be to teach the idiomatic usage, not just the features. There are others that would serve equally well. The mental model needs to be taught along with the language. That is a pedagogical issue.
However for someone with less background in language principles and in programming pedagogy, I'd probably rather recommend Python or Java, just because of the wealth of teaching materials available, combined with a rational abstraction model. Creating good teaching materials in any language is hard work.
I'll also note here that many people have the experience that the second language they learn is the hardest, especially if it is either quite similar or quite different. That is due to the fact that your first language teaches you (you believe) how to program, so, the new language feels awkward and one tries to apply the idioms of the old language to the new one. It won't work. Even languages as close as Java and Ruby have different idioms.
I would make it hands on and C-based, with very little OOP in the beginning. You can code in C++ using it as a "better" C. You'd introduce classes by the way without making a big deal of OO stuff. I'd focus on I/O, data structures, particularly, containers such as lists and arrays, and algorithms such as search and sorting.
Maybe write simple utilities, e.g. renaming files in the directory using wild cards. Building pipes like in Unix tools, e.g. write on program that reads from input stream and replaces special characters with spaces, then output result into output stream. Then write another program that reads IOS and counts words, then outputs. Then you make a silly pipe out of these two etc. This type of exercise packs a lot of different concepts together and can make things interesting to non CS students. This stuff will easily fill the semester.