Professional Documents
Culture Documents
LGR Cheat Sheet
LGR Cheat Sheet
Uploaded by
Tien PhucOriginal Title
Copyright
Available Formats
Share this document
Did you find this document useful?
Is this content inappropriate?
Report this DocumentCopyright:
Available Formats
LGR Cheat Sheet
LGR Cheat Sheet
Uploaded by
Tien PhucCopyright:
Available Formats
version 1.0.
7
Table of Contents
Basic Types & Variables
Control Flow
References, Ownership, and Borrowing
Pattern Matching
Iterators
Error Handling
Combinators
Multiple error types
Iterating over errors
Generics, Traits, and Lifetimes
Functions, Function Pointers & Closures
Pointers
Smart pointers
Packages, Crates, and Modules
YouTube Channel:https://www.youtube.com/c/LetsGetRusty
Basic Types & Variables Struct
/ Definition
/
bool- Boolean
struct
User
{
username:
String
,
nsigned integers
U
active:
bool,
u8,u16,u32,u64,u128
}
igned integers
S
/ Instantiation
/
i8,i16,i32,i64,i128
let
user1 = User {
username:
String
::from(
"bogdan"
),
loating point numbers
F
active:
true
,
f32,f64
};
latform specific integers
P
/ Tuple struct
/
usize- Unsigned integer. Same number of bits as the
struct
Color
(
i
32
,
i32,
i32);
platform's pointer type.
let
black = Color(
0
,
0,
0
)
;
isize- Signed integer. Same number of bits as the
platform's pointer type. Enum
/ Definition
/
har-Unicode scalar value
c enum
Command
{
&str- String slice Quit,
String- Owned string Move { x:
i32, y:
i32
},
Speak(
String
),
Tuple ChangeBGColor(
i32
,
i32
,
i32
),
et
l coordinates = (
82
,
64
);
}
let
score = (
"Team A"
,
12
)
/ Instantiation
/
let
msg1 = Command::Quit;
Array & Slice
let
msg2 = Command::Move{ x:1
, y:
2
};
/ Arrays must have a known length and all
/ let
msg3 = Command::Speak("Hi"
.to_owned());
elements must be initialized
let
msg4 = Command::ChangeBGColor(0
,
0,
0
)
;
let
array = [
1
,
2,
3
,
4
,
5
]
;
let
array2 = [
0
;
3
]
; // [0, 0, 0]
Constant
/ Unlike arrays the length of a slice is
/ const
MAX_POINTS:
u32
=
100_000
;
determined at runtime
let
slice = &array[
1
..
3];
Static variable
/ Unlike constants static variables are
/
HashMap // stored in a dedicated memory location
use
std::collections::HashMap; // and can be mutated.
static
MAJOR_VERSION:
u32
=
1
;
et
l mut
subs = HashMap::new(); static
mut
COUNTER:
u32
=
0
;
subs.insert(
String
::from(
"LGR"
),
100000
);
// Insert key if it doesn't have a value
subs.entry(
"Golang Dojo"
.to_owned())
.or_insert(
3
);
Mutability Returning from loops
et
l mut
x =
5
;
let
mut
counter =
0
;
x =
6
;
let
result =
loop
{
Shadowing counter +=
1;
et
l x =
5
;
if
counter ==
10{
let
x = x *
2
;
break
counter;
}
Type alias };
/ `NanoSecond` is a new name for `u64`.
/
type
NanoSecond
=
u64
;
while and while let
while
n <101
{
Control Flow n +=
1
;
}
if and if let
let
num =
Some
(
22
);
let
mut
optional =
Some
(
0
)
;
if
num.is_some() { while
letSome(i) = optional {
println!
(
"number is: {}"
, num.unwrap());
print!
(
"{}"
, i);
}
}
/ match pattern and assign variable
/ for loop
if
let
Some(i) = num {
println!
(
"number is: {}"
, i);
for
n
in
1
.
.101
{
}
println!
(
"{}"
, n);
}
loop let
names =
vec!
[
"
Bogdan"
,
"Wallace"
];
et
l mut
count =
0;
loop
{ for
name
innames.iter() {
count +=
1
;
println!
(
"{}"
, name);
if
count ==
5
{ }
break
;
// Exit loop
}
match
}
let
optional =
Some
(
0
)
;
Nested loops & labels match
optional {
'outer
:
loop
{ Some
(i) =>
println!(
"{}"
, i),
'inner
:
loop
{ None
=>
println!
(
"
No value.")
// This breaks the inner loop
}
break
;
// This breaks the outer loop
break
'outer
;
}
}
eferences, Ownership, and
R Ownership and functions
Borrowing fn
main
() {
let
x =
5;
Ownership rules takes_copy(x);
// x is copied by value
1. Each value in Rust has a variable that’s called its
owner. et
l s =
String
::from(
"Let’s Get Rusty!"
);
2. There can only be one owner at a time. // s is moved into the function
3. When the owner goes out of scope, the value will takes_ownership(s);
be dropped.
/ return value is moved into s1
/
Borrowing rules let
s1 = gives_ownership();
1. At any given time, you can haveeitherone
mutable referenceorany number of immutable et
l s2 =
String
::from(
"LGR"
);
references. let
s3 = takes_and_gives_back(s2);
2. References must always be valid. }
Creating references fn
takes_copy(some_integer:
i32
) {
et
l s1 =
String
::from(
"hello world!"
);
println!
(
"{}"
, some_integer);
let
s1_ref = &s1;
// immutable reference }
et
l mut
s2 =
String::from(
"hello"
);
fn
takes_ownership(some_string:
String
) {
let
s2_ref = &
mut
s2;// mutable reference println!
(
"{}"
, some_string);
}
// some_string goes out of scope and drop
s2_ref.push_str(
" world!"
);
is called. The backing memory is freed.
fn
gives_ownership
() ->
String
{
Copy, Move, and Clone let
some_string =
String
::from(
"LGR"
);
/ Simple values which implement the Copy
/ some_string
trait are copied by value
}
let
x =
5
;
let
y = x; n
f takes_and_gives_back
(some_string:
String
) ->
String
{
println!
(
"{}"
, x);
// x is still valid some_string
}
/ The string is moved to s2 and s1 is
/
invalidated
let
s1 =
String
::from(
"Let's Get Rusty!"
);
let
s2 = s1;
// Shallow copy a.k.a move
println!
(
"{}"
, s1);
// Error: s1 is invalid
et
l s1 =
String
::from(
"Let's Get Rusty!"
);
let
s2 = s1.clone();
// Deep copy
/ Valid because s1 isn't moved
/
println!
(
"{}"
, s1);
Pattern Matching Ignoring values
struct
SemVer
(
i32
,
i32
,
i32
);
Basics
let
x =
5
;
let
version = SemVer(
1
,
32
,
2
)
;
match
x { match
version {
// matching literals
SemVer(major, _, _) => {
1
=>
println!
(
"one"
),
println!
(
"
{}"
, major);
// matching multiple patterns
}
2
|
3
=>
println!
(
"two or three"
),
}
// matching ranges
4
..=
9
=>
println!
(
"within range"
),
let
numbers = (
2
,
4
,
8,
16
,
32
);
// matching named variables
x =>
println!
(
"{}"
, x),
match
numbers {
// default case (ignores value)
(first, .., last) => {
_ =>
println!
(
"default Case"
)
println!
(
"
{}, {}"
, first, last);
}
}
}
Destructuring
struct
Point
{ Match guards
x:
i32
,
let
num =
Some
(
4
)
;
y:
i32
,
}
match
num {
Some
(x)
if
x <
5
=>println!
(
"
less than
let
p = Point { x:
0
,
y:
7
}; five: {}"
, x),
Some
(x) =>
println!
(
"{}"
, x),
match
p { None
=> (),
Point { x, y:
0
} => { }
println!
(
"{}"
, x);
},
@ bindings
Point { x, y } => {
println!
(
"{} {}"
, x, y); struct
User
{
},
id:
i32
}
}
enum
Shape
{ let
user = User { id:
5
};
Rectangle { width:
i32
, height:
i32
},
Circle(
i32
),
match
user {
}
User {
id: id_variable @
3
.
.=7
,
let
shape = Shape::Circle(
10
);
} =>
println!
(
"
id: {}", id_variable),
User { id:
10
..=
12
} => {
match
shape { println!
(
"
within range" );
Shape::Rectangle { x, y } =>
//... },
Shape::Circle(radius) =>
//... User { id } =>
println!(
"id: {}"
, id),
}
}
Iterators Error Handling
Usage Throw unrecoverable error
/ Methods that consume iterators
/ panic!
(
"Critical error! Exiting!"
);
let
v1 =
vec!
[
1
,
2
,
3];
let
v1_iter = v1.iter(); Option enum
let
total:
i32
= v1_iter.sum();
fn
get_user_id(name: &
str
) ->
Option
<
u
32
> {
/ Methods that produce new iterators
/ if
database.user_exists(name) {
let
v1:
Vec
<
i32
> =
vec!
[
1
,
2
,
3];
return
Some
(database.get_id(name))
let
iter = v1.iter().map(|x| x + 1
)
; }
/ Turning iterators into a collection
/ None
let
v1:
Vec
<
i32
> =
vec!
[
1
,
2
,
3];
}
let
v2:
Vec
<_> = v1.iter().map(|x| x +
1
).collect();
Result enum
n
f get_user(id:
u32
) ->
Result
<User, Error>
Implementing the Iterator trait {
struct
Counter
{ if
is_logged_in_as(id) {
count:
u32
,
return
Ok
(get_user_object(id))
}
}
impl
Counter { Err
(Error { msg:
"not logged in"
})
fn
new
() -> Counter {
}
Counter { count:
0
}
}
? operator
}
n
f get_salary(db: Database, id:
i32
) ->
Option
<
u32
> {
impl
Iterator
for
Counter {
Some
(db.get_user(id)?.get_job()?.salary)
type
Item
=
u32
;
}
n
f next
(&
mut
self
) ->
Option
<Self::Item>
n
f connect
(db: Database) ->
{
Result
<Connection, Error> {
if
self
.count <
5{
let
conn =
self
.count +=
1;
db.get_active_instance()?.connect()?;
Some
(
self
.count)
Ok
(conn)
}
else
{
}
None
}
}
}
Combinators Boxing errors
.map use
std::error;
let
some_string =
Some
(
"LGR"
.to_owned());
ype
t Result
<T> = std::result::
Result
<T,
Box
<dyn error::Error>>;
et
l some_len = some_string.map(|s|
s.len());
Iterating over errors
truct
s Error
{ msg:
String
} Ignore failed items with filter_map()
struct
User
{ name:
String
}
et
l strings =vec!
[
"
LGR"
,
"22",
"7"
];
let
numbers:
Vec<_> = strings
et
l string_result:
Result<
S
tring
, Error> =
.into_iter()
Ok
(
"Bogdan"
.to_owned());
.filter_map(|s| s.parse::<
i32
>().ok())
.collect();
let
user_result:
Result
<User, Error> =
string_result.map(|name| {
User { name }
Fail the entire operation with collect()
});
let
strings =
vec!
[
"
LGR"
,
"22"
,
"7"
];
.and_then let
numbers:
Result
<
V
ec
<_>, _> = strings
.into_iter()
et
l vec =
Some
(
vec!
[
1
,
2
,
3]);
.map(|s| s.parse::<
i32
>())
let
first_element = vec.and_then(
.collect();
|vec| vec.into_iter().next()
);
Collect all valid values and failures with partition()
et
l string_result:
Result
<&
'static
str
, _>
let
strings =
vec!
[
"
LGR"
,
"22"
,
"7"
];
=
Ok
(
"
5"
);
let
number_result = et
l (numbers, errors): (
Vec
<_>,
Vec
<_>) =
string_result
strings
.and_then(|s| s.parse::<
u32
>());
.into_iter()
.map(|s| s.parse::<
i32
>())
Multiple error types .partition(
Result
::is_ok);
Define custom error type
let
numbers:
Vec
<_> = numbers
ype
t Result
<T> = std::result::
Result
<T,
.into_iter()
CustomError>;
.map(
Result
::unwrap)
.collect();
[derive(Debug, Clone)]
#
struct
CustomError
;
let
errors:
Vec<_> = errors
.into_iter()
impl
fmt::Display
for
CustomError { .map(
Result
::unwrap_err)
fn
fmt
(&
self
, f: &
mut
fmt::Formatter) -> .collect();
fmt::
Result
{
write!
(f,
"custom error message"
)
}
}
Generics, Traits, and Lifetimes Trait bounds
n
f largest
<T:
PartialOrd
+Copy
>(list:
Using generics
&[T]) -> T {
struct
Point
<T, U> {
let
mut
largest = list[
0
];
x: T,
y: U,
for
&itemin
list {
}
if
item > largest {
largest = item;
impl
<T, U> Point<T, U> {
}
fn
mixup
<V, W>(
self
, other: Point<V, W>)
}
-> Point<T, W> {
Point {
argest
l
x:
self
.x,
}
y: other.y,
}
impl trait
}
}
n
f make_adder_function(y:
i32
) ->
impl
Fn
(
i32
) ->
i32
{
let
closure =
move
|x:i32
| { x + y };
Defining traits
closure
trait
Animal
{ }
fn
new
(name: &
'static
str
) ->
Self
;
fn
noise
(&
self
) -> &
'static
str
{
""
}
Trait objects
}
pub
struct
Screen
{
struct
Dog
{ name: &
'static
str
} pub
components:
Vec
<
Box
<dyn Draw>>,
}
impl
Dog {
fn
fetch
() {
// ...
} Operator overloading
}
use
std::ops::Add;
impl
Animal
for
Dog {
[derive(Debug, Copy, Clone, PartialEq)]
#
fn
new
(name: &
'static
str
) -> Dog {
struct
Point
{
Dog { name: name }
x:
i32
,
}
y:
i32
,
}
fn
noise
(&
self
) -> &
'static
str
{
"woof!"
impl
Add
for
Point {
}
type
Output= Point;
}
fn
add
(
self
, other: Point) -> Point {
Default implementations with Derive Point {
/ A tuple struct that can be printed
/ x:
self
.x + other.x,
#[derive(Debug)]
y:
self
.y + other.y,
struct
Inches
(
i
32);
}
}
}
Supertraits Function pointers
use
std::fmt; n
f do_twice
(f:
fn
(
i32
) ->
i32
, arg:
i32
) ->
i32
{
trait
Log
: fmt::Display {
f(arg) + f(arg)
fn
log
(&
self
) {
}
let
output =
self
.to_string();
println!
(
"Logging: {}"
, output);
Creating closures
}
}
let
add_one = |num:
u32
| ->
u32
{
num +
1
};
Lifetimes in function signatures
n
f longest<
'a
>(x: &
'a
str, y: &
'a
str
) ->
Returning closures
&
'a
str
{
if
x.len() > y.len() { fn
add_one
() ->
impl
Fn
(
i
32
) ->
i32
{
x
|x| x +
1
}
else
{ }
y
}
n
f add_or_subtract (x:
i32
) ->
Box
<dyn
}
Fn
(
i32
) ->
i32> {
if
x >10
{
Box
::new(
move
|y| y + x)
Lifetimes in struct definitions }
else {
struct
User
<
'a
> {
Box
::new(
move
|y| y - x)
full_name: &
'a
str
,
}
}
}
Static lifetimes Closure traits
let
s: &
'static
str
=
"Let’s Get Rusty!"
;
● FnOnce- consumes the variables it captures
from its enclosing scope.
● FnMut- mutably borrows values from its
unctions, Function Pointers &
F enclosing scope.
Closures ● Fn- immutably borrows values from its enclosing
scope.
Associated functions and methods
struct
Point
{ x:
i32
, y:
i32
, }
Store closure in struct
truct
s Cacher<T>
impl
Point { where
// Associated function
T:
Fn
(
u
32) ->
u32
,
fn
new
(x:
i32
, y:
i32
) -> Point {
{
Point { x: x, y: y }
calculation: T,
}
value:
Option
<
u
32
>,
}
/ Method
/
fn
getX
(&
self
) ->
i32
{
self
.x }
}
Function that accepts closure or function pointer Packages, Crates, and Modules
fn
do_twice
<T>(f: T, x:
i32
) ->
i32
Definitions
where
T:
Fn
(
i
32
) ->
i32
● Packages- A Cargo feature that lets you build,
{
test, and share crates.
f(x) + f(x)
● Crates- A tree of modules that produces a
}
library or executable.
● Modulesanduse- Let you control the
Pointers organization, scope, and privacy of paths.
● Paths- A way of naming an item, such as a
References
struct, function, or module.
et
l mut
num =
5
;
let
r1 = #
// immutable reference Creating a new package with a binary crate
let
r2 = &
mut
num;
// mutable reference
$ cargo new my-project
Raw pointers
Creating a new package with a library crate
et
l mut
num =
5
;
$ cargo new my-project --lib
// immutable raw pointer
let
r1 = &num
as*
c
onst
i32;
// mutable raw pointer
Defining and using modules
let
r2 = &
mut
numas
*
m
ut
i32;
fn
some_function
() {}
Smart pointers mod
outer_module {// private module
pub
mod
inner_module {// public module
Box<T>- for allocating values on the heap
pub
fninner_public_function
() {
let
b =
Box
::new(
5
); super::super::some_function();
}
Rc<T>-multiple ownership with reference counting
n
f inner_private_function
() {}
et
l a = Rc::new(
5
);
}
let
b = Rc::clone(&a);
}
ef<T>, RefMut<T>, and RefCell<T>- enforce
R fn
main
() {
borrowing rules at runtime instead of compile time. // absolute path
et
l num =
5
;
crate::outer_module::
let
r1 = RefCell::new(
5
);
inner_module::inner_public_function();
// Ref - immutable borrow
let
r2 = r1.borrow(); / relative path path
/
// RefMut - mutable borrow
outer_module::
let
r3 = r1.borrow_mut(); inner_module::inner_public_function();
// RefMut - second mutable borrow
let
r4 = r1.borrow_mut(); / bringing path into scope
/
use
outer_module::inner_module;
inner_module::inner_public_function();
Multiple owners of mutable data
}
let
x = Rc::new(RefCell::new(
5
)
);
Renaming withaskeyword Defining modules in separate files
se
u std::fmt::
Result
;
/ src/lib.rs
/
use
std::io::
Result
as
IoResult; mod
my_module;
Re-exporting withpub use pub
fn
some_function
() {
my_module::my_function();
mod
outer_module { }
pub
mod
inner_module {
pub
fn
inner_public_function
() {}
/ src/my_module.rs
/
}
pub
fn
my_function
() {}
}
pub
use
crate::outer_module::inner_module;
You might also like
- Spring MCQDocument42 pagesSpring MCQRiyad Hossain40% (5)
- Assignment 2 Object-Oriented Program Development: 1. DescriptionDocument3 pagesAssignment 2 Object-Oriented Program Development: 1. Descriptiondao dinh quangNo ratings yet
- Bank Operations Using C#Document3 pagesBank Operations Using C#NISHANo ratings yet
- Libreofice Basic: Libreoffe RefcardDocument2 pagesLibreofice Basic: Libreoffe RefcardEugene StepNo ratings yet
- Capgemini Interview QuestionDocument5 pagesCapgemini Interview QuestionprasadNo ratings yet
- Modbus Table Daniel 3410 Ultrasonic Meter Firmware v1 44 en 55830Document153 pagesModbus Table Daniel 3410 Ultrasonic Meter Firmware v1 44 en 55830Dan SantosNo ratings yet
- 001 Core 15 - Java Programming - III SemDocument78 pages001 Core 15 - Java Programming - III SemYaseen GNo ratings yet
- C2 Docx-2Document6 pagesC2 Docx-2Math HelperNo ratings yet
- Chapter 04 SlidesDocument57 pagesChapter 04 SlidesGoran WnisNo ratings yet
- Algorithms Stock Problem With A Different: Local Search For The Cutting Given Number of PatternsDocument10 pagesAlgorithms Stock Problem With A Different: Local Search For The Cutting Given Number of PatternsAung Zaw MoeNo ratings yet
- Lecture04 2023 MarkedDocument57 pagesLecture04 2023 Marked13684962573No ratings yet
- Cheatsheets - AMIQ Consulting - SVDocument5 pagesCheatsheets - AMIQ Consulting - SVnazimNo ratings yet
- LectureN 2Document19 pagesLectureN 2yogapriya.kvNo ratings yet
- Chapter Two OppDocument26 pagesChapter Two OppHaymanot MatebieNo ratings yet
- C - 2 NotesDocument36 pagesC - 2 NotesJyotir BhattNo ratings yet
- C++ Clean SheetDocument2 pagesC++ Clean Sheetaung sun lynnNo ratings yet
- Week 01 Lab 02 CarsDocument2 pagesWeek 01 Lab 02 Carsulfany.guimelNo ratings yet
- C Sharp (C#) Online Training: By: Ajeet KumarDocument21 pagesC Sharp (C#) Online Training: By: Ajeet KumarKumar KashyapNo ratings yet
- VHDL Lang PDFDocument11 pagesVHDL Lang PDFRachel RajanNo ratings yet
- University of Toronto Faculty of Applied Science and Engineering Aps106 Midterm Ii - March 27, 2014Document5 pagesUniversity of Toronto Faculty of Applied Science and Engineering Aps106 Midterm Ii - March 27, 2014Jungho Justin KimNo ratings yet
- OpenGL ES 2 0 Reference CardDocument4 pagesOpenGL ES 2 0 Reference Cardn3m6No ratings yet
- Structure of C++ Programs Structure of C++ ProgramDocument30 pagesStructure of C++ Programs Structure of C++ ProgramskirubaarunNo ratings yet
- Matrix Class Project Final ReportDocument21 pagesMatrix Class Project Final ReportShehab AhmedNo ratings yet
- DLCA - TechNeoDocument132 pagesDLCA - TechNeoBhumi Avhad100% (1)
- Muhammad Rafay - MCT-242L CP (Fall2022) - Lab 03 - Data-Types and Variables in CDocument8 pagesMuhammad Rafay - MCT-242L CP (Fall2022) - Lab 03 - Data-Types and Variables in CMuhammad RafayNo ratings yet
- Int 0 Char '/0' Float 0 Double 0 Null: G Main (A, B A 10 B 20 G A + B Std::cout A B GDocument17 pagesInt 0 Char '/0' Float 0 Double 0 Null: G Main (A, B A 10 B 20 G A + B Std::cout A B GOleg DudiXNo ratings yet
- Lesson 2: Data Types. Program Structure / Input - Output. SelectionDocument42 pagesLesson 2: Data Types. Program Structure / Input - Output. SelectionJonny CerneiNo ratings yet
- Mathematical Methods 18Document3 pagesMathematical Methods 18rapsjadeNo ratings yet
- HomeworkDocument1 pageHomeworkalyssallim934No ratings yet
- StataCheatSheet AnalysisDocument1 pageStataCheatSheet AnalysisSagardeep RoyNo ratings yet
- C - Data Structures+IODocument42 pagesC - Data Structures+IONguyễn DươngNo ratings yet
- C - Library - StdlibDocument3 pagesC - Library - StdlibtrgyklNo ratings yet
- Class 02Document9 pagesClass 02Tina NguyenNo ratings yet
- Opengl42 Quick Reference CardDocument12 pagesOpengl42 Quick Reference Card5ROJQ6LlNo ratings yet
- DBSchemaDocument4 pagesDBSchemaMystiqueNo ratings yet
- C Data Type NoteDocument22 pagesC Data Type Notevickroid007No ratings yet
- Linking Paper and Digital MediaDocument18 pagesLinking Paper and Digital MediaBeat SignerNo ratings yet
- Increased Productivity of An Automated Tape Winding System: SPIDE-TP PlatformDocument1 pageIncreased Productivity of An Automated Tape Winding System: SPIDE-TP PlatformkikorrasNo ratings yet
- JS Typed ArraysDocument6 pagesJS Typed Arraysnipu90No ratings yet
- Verilog TutorialDocument109 pagesVerilog TutorialRamkumardevendiranDevenNo ratings yet
- Mechanized Semantics For The Clight Subset of The C LanguageDocument25 pagesMechanized Semantics For The Clight Subset of The C LanguageZap ItuNo ratings yet
- Basic Python ProgrammingDocument24 pagesBasic Python ProgrammingVILLAHERMOSA, JULIE ANNNo ratings yet
- CS3353 Unit1Document43 pagesCS3353 Unit1Padmapriya ThianuNo ratings yet
- VHDL QuickrefDocument2 pagesVHDL QuickrefNidhiNo ratings yet
- Graphql Shorthand Notation Cheat SheetDocument1 pageGraphql Shorthand Notation Cheat SheetHéla Ben KhalfallahNo ratings yet
- C Session2Document29 pagesC Session2YogiNo ratings yet
- Blog DB DesignDocument1 pageBlog DB DesignAbikananda PrustyNo ratings yet
- Microsoft x64 Software ConventionsDocument60 pagesMicrosoft x64 Software ConventionsFernan Esco GuerNo ratings yet
- 4 Singly Linked Listpdf Lyst7205Document7 pages4 Singly Linked Listpdf Lyst7205pumpkin.baba123No ratings yet
- Modelo InicialDocument5 pagesModelo InicialisraeldelNo ratings yet
- Visit: A Small Contribution Would Support Us.: Stay Connected Get Updated Ask Your QueriesDocument4 pagesVisit: A Small Contribution Would Support Us.: Stay Connected Get Updated Ask Your QueriesKruNo ratings yet
- Embedding Assembly Instructions Inside C-Source Code: Technical Note TN-18Document3 pagesEmbedding Assembly Instructions Inside C-Source Code: Technical Note TN-18Mothaiba TacungmuaNo ratings yet
- Imrad: Scientific Writing of A Research Article According To Imrad StructureDocument16 pagesImrad: Scientific Writing of A Research Article According To Imrad StructureBEKHTI BrahimNo ratings yet
- Flash AS3 and AVM2: Performance TuningDocument74 pagesFlash AS3 and AVM2: Performance TuningEd McManus100% (2)
- Proteus Simulation Based Pic Projects - PIC MicrocontrollerDocument30 pagesProteus Simulation Based Pic Projects - PIC MicrocontrollerElie RaffoulNo ratings yet
- Data Types Format Type Conversion Variables Constants Storage ClassesDocument10 pagesData Types Format Type Conversion Variables Constants Storage ClassesOwimarkNo ratings yet
- CD-compiler Designe AkashDocument70 pagesCD-compiler Designe AkashElon muskNo ratings yet
- Basic ConceptsDocument39 pagesBasic ConceptsVinay KumarNo ratings yet
- Thapar Institute of Engineering & Technology, Patiala: Soom DesthadmDocument1 pageThapar Institute of Engineering & Technology, Patiala: Soom DesthadmHarman MaanNo ratings yet
- 8. MatricesDocument7 pages8. Matricesmanish kumarNo ratings yet
- RAP With BAPIDocument12 pagesRAP With BAPILuis MariñoNo ratings yet
- Week 1 - Lecture 1Document38 pagesWeek 1 - Lecture 1Faizy GiiNo ratings yet
- Object Oriented Programming (OOPs) or C++ Sample Paper of MSBTE For Third Semester Computer Engineering Diploma (80 Marks)Document3 pagesObject Oriented Programming (OOPs) or C++ Sample Paper of MSBTE For Third Semester Computer Engineering Diploma (80 Marks)Sanjay Dudani89% (9)
- Method Overloading in JavaDocument6 pagesMethod Overloading in JavaPrerna GourNo ratings yet
- 400+ Javascript Interview QuestionsDocument176 pages400+ Javascript Interview QuestionsLuan100% (1)
- Python Programming With The Java Class Libraries - A TutoriaDocument557 pagesPython Programming With The Java Class Libraries - A Tutoriaacytra23No ratings yet
- Wearing The Hair ShirtDocument68 pagesWearing The Hair ShirtsashishkNo ratings yet
- Ch03 Class and ObjectsDocument17 pagesCh03 Class and ObjectsMahaveer SutharNo ratings yet
- Exercice Session 0 - ModularityDocument4 pagesExercice Session 0 - Modularitynniko6740No ratings yet
- Oop Programs Solved PDFDocument45 pagesOop Programs Solved PDFShani TahirNo ratings yet
- OOP Lab Report - 2Document10 pagesOOP Lab Report - 2EvaNo ratings yet
- Assignment - 2 SolutionDocument5 pagesAssignment - 2 SolutionPragati ojhaNo ratings yet
- Chapter 4 - Book InventoryDocument5 pagesChapter 4 - Book Inventoryapi-581369232No ratings yet
- 3 InheritanceDocument48 pages3 InheritanceM Srinivasan Mca MPhilNo ratings yet
- Imperative Functional Programming Philip WadlerDocument15 pagesImperative Functional Programming Philip WadlerShubham Anil ShahareNo ratings yet
- Primeri Za Implementacija Na Magacin I Red So ListiDocument5 pagesPrimeri Za Implementacija Na Magacin I Red So Listiabuser233No ratings yet
- Object Pool Design PatternDocument16 pagesObject Pool Design PatternykamranNo ratings yet
- C, C++ Questions: Ans. BDocument14 pagesC, C++ Questions: Ans. BkmbkrisNo ratings yet
- Dot NetDocument9 pagesDot NetSuruBabuThalupuruNo ratings yet
- Billing Project Complete C++Document8 pagesBilling Project Complete C++Abubakar ChaudhryNo ratings yet
- Advanced RDBMS: Unit-I Page NoDocument3 pagesAdvanced RDBMS: Unit-I Page NoJit AggNo ratings yet
- Classes and ObjectsDocument8 pagesClasses and ObjectsINDLA MAHESH100% (1)
- 21cs33 (Object Oriented Programming With Java)Document2 pages21cs33 (Object Oriented Programming With Java)Dhanush NNo ratings yet
- Btech JNTU CSE-2-1-DSDocument2 pagesBtech JNTU CSE-2-1-DSvijaykumar015No ratings yet
- Oracle Certified Associate, Java SE 7 Programmer Study Guide - ErrataDocument6 pagesOracle Certified Associate, Java SE 7 Programmer Study Guide - ErrataMarcio Soares PereiraNo ratings yet
- Methods in JavaDocument4 pagesMethods in Javaarunverma47No ratings yet
