Cách may mũ vải cho bé điệu đà mùa thu đông và những mẫu mũ đẹp hợp thời trang

Mũ vải hoặc mũ len là một trong những phụ kiện thời trang quan trọng cho bé sử dụng trong những ngày mùa thu đông. Mũ vải dùng trong những ngày trời mát lạnh nhè nhẹ còn mũ len dùng cho bé khi trời trở rét. Để bé luôn xinh xắn khi ra đường dạo phố các mẹ hãy chọn cho bé những mẫu mũ vải thật dễ thương nhé. Sau đây hướng dẫn các mẹ cách may mũ vải cho bé yêu.

Chưa đủ rét để đội mũ len nhưng mỗi sớm và chiều của những ngày giao mùa thu đông này cũng đủ se lạnh, bạn thử cách may mũ vải này để may mũ cho bé nhé!

Nguyên vật liệu cần thiết dùng để may mũ vải cho bé.

Theo 3 cách may mũ vải ấm áp cho bé, bạn cần chuẩn bị những nguyên vật liệu sau đây:

- Vải cotton có chút co giãn, thường là cotton thun, nếu bạn chọn được cotton dệt kim càng tốt.

- Máy may chỉ chập (đường vắt sổ kiêm đường may), nếu chỉ có máy vắt sổ rời thì bạn may xong rồi vắt sổ hai mép biên vải chung một cũng được, nếu chỉ có mỗi máy may hoặc dùng cách khâu tay thì bạn nên dùng cách may lộn.

Kỹ thuật may lộn:

May trên mặt phải, đường biên may to 1cm hoặc to hơn chút xíu.

Cắt giảm nửa biên vải của một lớp vải ngoài đường biên.

Gập đôi biên may to hơn bao kín đường biên may nhỏ hơn.

Ép phần biên vừa gập nằm bẹp sang một bên, bạn nên dùng bàn là để là chết nếp gập cho dễ may.

May sát biên gập, đường chỉ sẽ song song với đường may ban đầu ở mặt phải.

Kết quả bạn sẽ có một đường may lộn có hai đường chỉ song song ở mặt phải, bên mặt trái chỉ lộ một đường chỉ, nhưng mặt vải trơn liền nhau không có đường biên may cộm lên như thông thường.

- Kéo, mẫu giấy: in mẫu bên sao cho độ rộng ngang hình mũ bằng 1/2 vòng đầu của bé chỗ nở rộng nhất. Cắt hình in làm mẫu giấy.

Cách may mũ vải cho bé

Có 3 mẫu mũ cho bạn lựa chọn, mỗi mẫu sẽ gồm một phần cạp vành mũ và một phần thân chính. Gập đôi vải rồi căn ke mẫu giấy lên vải và cắt theo để có cùng lúc 2 phần mũ trước và sau bằng nhau nhưng trái mặt vải. “Mũ gấu” cắt thêm 4 miếng tai giống nhau, rộng hơn nửa hình tròn một chút.

Để may mũ có thắt nút trên chóp, bạn ráp hai mặt phải mũ lại với nhau, may ráp bao quanh trừ đường vành mũ. Lộn phải vải có phần trên mũ, thắt nút ở phần thuôn nhỏ phía trên. Phần vành mũ rời thì được ráp từ hai miếng vải hình chữ nhật, may lại như ống vải rồi gập đôi cho hai bên đều là mặt phải. May ráp vành mũ vào thân mũ là hoàn thành.

Để may mũ tròn cơ bản, bạn may ráp 2 đường khía múi ngắn ở trên chóp mũ, sau đó mới áp hai nửa mũ vào nhau và ráp một đường cung liên mạch, phần vành mũ làm tương tự ở bước 2 và may ráp vào thân mũ là xong.

Mũ gấu được may tương tự như mũ tròn cơ bản ở bước 3, nhưng trước khi may ráp 2 miếng mũ thì bạn cần may ráp tai đã. Vành mũ muốn đỡ cộm thì bạn may hai lần, lần thứ nhất may mép của một lớp vải vào phần vành thân mũ, lần thứ hai may mép còn lại đã được gập dấu nếp vào trong. Nói chung tương tự như may nẹp, chỉ khác là chiếc nẹp này to gấp đôi vành mũ (vì còn gập vành mũ lên).

Thành phẩm là chiếc mũ vải xinh xinh cho bé

Rất nhanh chóng và dễ dàng, bạn có thể may được 3 kiểu mũ vải ấm áp cho bé đội thay đổi đầy sinh động và tiện dụng cho những ngày thu se lạnh. Vải cotton luôn thấp tháp giúp bé không chỉ giữ ấm mà còn giúp bé nếu có lỡ dịn mồ hôi thì cũng được thấm rất nhanh và mau khô thoáng. Đây là những kiểu mũ hợp nhất với các bé sơ sinh.

Bạn có thể dùng vải len để may những kiểu mũ này cho bé, nên may thêm một lớp mũ nữa bằng vải cotton mỏng để may lót bên trong những mũ vải len. Chúc bạn thành công nhé!

Nhiều kiểu mẫu mũ vải xinh xinh cho bé gái cho các mẹ lựa chọn

Mẫu mũ vải cho bé gái 1: Hồng phấn đỏ kẻ sọc. Trông bé đội mũ này rất dễ thương phải không nào.

Mẫu mũ vải cho bé gái 2: Hồng nhạt, rất thích hợp cho những bé gái có làn da trắng bóc.

Mẫu mũ vải cho bé gái 3: sọc hồng nhạt có thắt nơ đỏ.

Mẫu mũ vải cho bé gái 4: sọc nước biển nhạt có thắt nơ đỏ. Thử tưởng tượng xem bé gái của bạn đội nón này sẽ xinh như thế nào.

Theo 2thoitrangtreem

hash_map in C++

The current C++ standard does not have hash maps, but the coming C++0x standard does, and these are already supported by g++ in the shape of "unordered maps":

#include <unordered_map>
#include <iostream>
#include <string>
using namespace std;

int main() {
    unordered_map <string, int> m;
    m["foo"] = 42;
    cout << m["foo"] << endl;
}

In order to get this compile, you need to tell g++ that you are using C++0x:

g++ -std=c++0x -o main main.cpp

.\main

These maps work pretty much as std::map does, except that instead of providing a custom operator<() for your own types, you need to provide a custom hash function - suitable functions are provided for types like integers and strings.

Abstract Class vs Interface in C++

I assume that with interface you mean a C++ class with only pure virtual methods (i.e. without any code), instead with abstract class you mean a C++ class with virtual methods that can be overridden, and some code, but at least one pure virtual method that makes the class not instantiable. e.g.:

class MyInterface
{
public:
  // Empty virtual destructor for proper cleanup
  virtual ~MyInterface() {}

  virtual void Method1() = 0;
  virtual void Method2() = 0;
};


class MyAbstractClass
{
public:
  virtual ~MyAbstractClass();

  virtual void Method1();
  virtual void Method2();
  void Method3();

  virtual void Method4() = 0; // make MyAbstractClass not instantiable
};

In Windows programming, interfaces are fundamental in COM. In fact, a COM component exports only interfaces (i.e. pointers to v-tables, i.e. pointers to set of function pointers). This helps defining an ABI(Application Binary Interface) that makes it possible to e.g. build a COM component in C++ and use it in Visual Basic, or build a COM component in C and use it in C++, or build a COM component with Visual C++ version X and use it with Visual C++ version Y. In other words, with interfaces you have high decoupling between client code and server code.

Moreover, when you want to build DLL's with a C++ object-oriented interface (instead of pure C DLL's), as described in this article, it's better to export interfaces (the "mature approach") instead of C++ classes (this is basically what COM does, but without the burden of COM infrastructure).

I'd use an interface if I want to define a set of rules using which a component can be programmed, without specifying a concrete particular behavior. Classes that implement this interface will provide some concrete behavior themselves.

Instead, I'd use an abstract class when I want to provide some default infrastructure code and behavior, and make it possible to client code to derive from this abstract class, overriding the pure virtual methods with some custom code, and complete this behavior with custom code. Think for example of an infrastructure for an OpenGL application. You can define an abstract class that initializes OpenGL, sets up the window environment, etc. and then you can derive from this class and implement custom code for e.g. the rendering process and handling user input:

// Abstract class for an OpenGL app.
// Creates rendering window, initializes OpenGL; 
// client code must derive from it 
// and implement rendering and user input.
class OpenGLApp
{
public:
  OpenGLApp();
  virtual ~OpenGLApp();
  ...

  // Run the app    
  void Run();


  // <---- This behavior must be implemented by the client ---->

  // Rendering
  virtual void Render() = 0;

  // Handle user input
  // (returns false to quit, true to continue looping)
  virtual bool HandleInput() = 0;

  // <--------------------------------------------------------->


private:
  //
  // Some infrastructure code
  //
  ... 
  void CreateRenderingWindow();
  void CreateOpenGLContext();
  void SwapBuffers();
};


class MyOpenGLDemo : public OpenGLApp
{
public:
  MyOpenGLDemo();
  virtual ~MyOpenGLDemo();

  // Rendering
  virtual void Render();  // implements rendering code

  // Handle user input
  virtual bool HandleInput(); // implements user input handling


  //  ... some other stuff
};

Lớp Trừu tượng & Giao diện (Abstract Classes & Interfaces) Java

1. Lớp Trừu tượng (Abstract Classes)

Lớp trừu tượng (Abstract Class) là lớp dùng để định nghĩa những thuộc tính và hành vi chung của những lớp khác..    Hay nói cách khác: Lớp trừu tượng là lớp dùng để khai báo thuộc tính và phương thức cho các lớp khác sử dụng.    (Lớp trừu tượng không cho phép khởi tạo tham số, chỉ khai báo mà thôi).    Lớp trừu tượng được dùng như một lớp cha (base class) của các lớp có cùng bản chất.    Bản chất ở đây được hiểu là kiểu, loại, nhiệm vụ của class.    Mỗi lớp dẫn xuất (derived class - lớp con) có thể thừa kế từ một lớp trừu tượng.    Từ khóa abstract được dùng để định nghĩa một Lớp trừu tượng.    Những lớp được định nghĩa bằng cách dùng từ khóa abstract thì không cho phép khởi tạo đối tượng (instance) của lớp ấy.    Ví dụ 1: Tạo đối tượng (instance/obj) cho lớp trừu tượng.   using System; using System.Collections.Generic; using System.Text; namespace Abstract_Class { //Định nghĩa 1 lớp trừu tượng abstract class NhanVien { protected string HoTen; protected int Tuoi; protected bool GioiTinh; } class Program { static void Main(string[] args) { NhanVien objPerson = new NhanVien(); } } }   Cannot create an instance of the abstract class or interface 'Abstract_Class.NhanVien' (Không thể tạo instance cho lớp trừu tượng và giao diện được)        Ví dụ 2: Định nghĩa 1 lớp trừu tượng có các thuộc tính & phương thức chung cho các lớp dẫn xuất sử dụng.   - Chúng ta nhận thấy, mối Nhân viên đều có các thuộc tính như: HoTen, Tuoi, GioiTinh. Nhưng ChucVu thì khác nhau.   - Ví dụ: Giám đốc có ChucVu là Giám đốc, Kế toán có ChucVu là Kế toán...   - Nên thuộc tính ChucVu ta khai báo trong lớp dẫn xuất - lớp con/derived class.    Định nghĩa lớp trừu tượng như sau:   using System; using System.Collections.Generic; using System.Text; namespace Abstract_Class { //Định nghĩa 1 lớp trừu tượng abstract class NhanVien { protected string HoTen; protected int Tuoi; protected bool GioiTinh; //Khai báo 1 phương thức trừu tượng bằng từ khoá abstract public abstract void CongViec(); } class Program { static void Main(string[] args) { } } }    Định nghĩa các lớp dẫn xuất GiamDoc và KeToan như sau:   using System; using System.Collections.Generic; using System.Text; namespace Abstract_Class { //Định nghĩa 1 lớp trừu tượng abstract class NhanVien { public string HoTen; public int Tuoi; public bool GioiTinh; //Khai báo 1 phương thức trừu tượng bằng từ khoá abstract public abstract void CongViec(); } //Định nghĩa lớp Dẫn xuất GiamDoc class GiamDoc : NhanVien { public string ChucVu; public override void CongViec() { //Code here } } //Định nghĩa lớp Dẫn xuất KeToan class KeToan : NhanVien { public string ChucVu; public override void CongViec() { //Code here } } class Program { static void Main(string[] args) { GiamDoc objGiamDoc = new GiamDoc(); objGiamDoc.HoTen = "Nguyen Van A"; objGiamDoc.Tuoi = 30; objGiamDoc.GioiTinh = true; objGiamDoc.ChucVu = "Giam Doc"; System.Console.WriteLine("Lop Dan xuat 'GiamDoc': {0}, {1}, {2}, {3}", objGiamDoc.HoTen, objGiamDoc.Tuoi, objGiamDoc.GioiTinh, objGiamDoc.ChucVu); KeToan objKeToan = new KeToan(); objKeToan.HoTen = "Nguyen Van B"; objKeToan.Tuoi = 26; objKeToan.GioiTinh = true; objKeToan.ChucVu = "Ke Toan"; System.Console.WriteLine("Lop Dan xuat 'Ke Toan': {0}, {1}, {2}, {3}", objKeToan.HoTen, objKeToan.Tuoi, objKeToan.GioiTinh, objKeToan.ChucVu); System.Console.ReadLine(); } } }

2. Giao diện (Interface )

1. Một vài định nghĩa:   Giao diện (Interface): là một chức năng mà ta có thể thêm và bất kì class nào. Chức năng ở đây không đồng nghĩa với phương thức (hoặc hàm).Interface có thể bao gồm nhiều hàm/phương thức và tất cả chúng cùng phục vụ cho một chức năng.   Như vậy, Interface được dùng để mô tả một "bản thiết kế" cho một chức năng của class. Nếu muốn tạo một bản thiết kế, hãy sử dụng abstract class. Một bản thiết kế tất nhiên sẽ có những thứ đã được dựng sẵn và có những thứ là abstract.   Interface không phải là lớp. Các lớp dẫn xuất từ 1 Interface đều phải định nghĩa đầy đủ các phương thức và thuộc tính kế thừa từ Interface.   Mục đích của một Interface là để định nghĩa những khả năng mà chúng ta muốn có trong một lớp.    2. Cài đặt một Giao diện:   Để hiểu rõ về Interface hơn, chúng ta tìm hiểu ví dụ sau:   - Giả sử có 2 lớp: Lớp Máy bay & Lớp Chim. Ta thấy Máy bay có chức năng bay. Chim cũng có khả năng bay.   - Ví dụ 1: Tạo Interface: Bay (IBay) cho lớp May bay & Lớp Chim thừa kế.     using System; using System.Collections.Generic; using System.Text; namespace Interface { //khai bao interface Bay public interface IBay { void Bay(); } //Lớp Chim thừa kế interface IBay public class Chim : IBay { public void Bay() { Console.WriteLine("Chim: Bay"); } } //Lớp MayBay thừa kế interface IBay public class MayBay : IBay { public void Bay() { Console.WriteLine("May Bay: Bay"); } } class Program { static void Main(string[] args) { Chim chim = new Chim(); chim.Bay(); MayBay maybay = new MayBay(); maybay.Bay(); System.Console.ReadLine(); } } }    3. Cài đặt nhiều Giao diện:    Trong ngôn ngữ C# cho phép chúng ta thực thi nhiều hơn một giao diện.    Các giao diện cách nhau bằng dấu phẩy ",".   - Ở ví dụ trên, chúng ta thấy rằng: Chim & Máy bay đều có khả năng Bay.   - Nhưng đồng thời Chim & Máy bay cũng có khả năng Chạy.   - Nên ta khai báo thêm 1 Interface Chạy có tên IChay.    Ví dụ 2: Cách C# thực thi nhiều giao diện.   using System; using System.Collections.Generic; using System.Text; namespace Interface { //khai báo interface Bay public interface IBay { void Bay(); } //khai báo interface Chạy public interface IChay { void Chay(); } //Lớp Chim thừa kế 2 interfaces IBay, IChay public class Chim : IBay, IChay { public void Bay() { Console.WriteLine("Chim: Bay"); } public void Chay() { Console.WriteLine("Chim: Chay"); } } //Lớp MayBay thừa kế 2 interfaces IBay, IChay public class MayBay : IBay, IChay { public void Bay() { Console.WriteLine("May Bay: Bay"); } public void Chay() { Console.WriteLine("May Bay: Chay"); } } class Program { static void Main(string[] args) { Chim chim = new Chim(); chim.Bay(); chim.Chay(); MayBay maybay = new MayBay(); maybay.Bay(); maybay.Chay(); System.Console.ReadLine(); } } }   - Kết quả:          4. Mở rộng Giao diện (tức là - Thừa kế Giao diện):    Chúng ta có thể mở rộng giao diện đã tồn tại bằng cách thêm vào đó những phương thức hoặc thành viên mới.    Chẳng hạn: Interface IBay có thể mở rộng thêm thành IDoCao (Độ Cao). Cho biết độ cao của Máy Bay & Chim.   //khai báo interface IDoCao thừa kế interface IBay public interface IDoCao:IBay { void DoCao(); }    5. Ép kiểu Giao diện:    Trong một vài trường hợp, chúng ta không biết đối tượng ấy hỗ trợ những giao diện loại gì.    Giả sử như Lớp MayBay, chúng ta không biết là nó hỗ trợ bởi giao diện IBay hay IChay hay là hỗ trợ cả hai?    Để giải quyết vấn đề này, chúng ta dùng cách "Ép kiểu giao diện".    Với cách này nó chỉ filter những phương thức thuộc Interface đó mà thôi.   MayBay maybay = new MayBay(); //Nó chỉ filter những phương thức của Interface IBay IBay isBay = (IBay)maybay; isBay.Bay(); //Nó chỉ filter những phương thức của Interface IChay IChay isChay = (IChay)maybay; isChay.Chay();    6. Cài đặt Giao diện một cách tường minh:    Một lớp có thể cài đặt nhiều giao diện nên có thể xảy ra trường hợp đụng độ về tên khi hai giao diện có cùng một tên hàm.    Để giải quyết xung đột này ta khai báo cài đặt một cách tường minh hơn.    Ví dụ: Nếu ta có hai giao diện IStorable và ITalk đều cùng có phương thức Read().    Lớp Document sẽ cài đặt hai giao diện này. Khi đó ta ta phải thêm tên giao diện vào trước tên phương thức    Ví dụ:   using System; using System.Collections.Generic; using System.Text; namespace Interface_Test { interface IStorable { void Read(); void Write(); } interface ITalk { void Read(); void Talk(); } public class Document : IStorable, ITalk { // document constructor public Document(string s) { Console.WriteLine("Creating document with: {0}", s); } // tạo read của IStorable public virtual void Read() { Console.WriteLine("Implementing IStorable.Read"); } public void Write() { Console.WriteLine("Implementing IStorable.Write"); } // cài đặt phương thức Read của ITalk void ITalk.Read() { Console.WriteLine("Implementing ITalk.Read"); } public void Talk() { Console.WriteLine("Implementing ITalk.Talk"); } } class Program { static void Main(string[] args) { // create a document object Document theDoc = new Document("Test Document"); // Ép kiểu để có thể gọi IStorable.Read() IStorable isDoc = theDoc as IStorable; if (isDoc != null) { isDoc.Read(); } // Ép kiểu để có thể gọi ITalk.Read() ITalk itDoc = theDoc as ITalk; if (itDoc != null) { itDoc.Read(); } theDoc.Read(); theDoc.Talk(); } } }