1  exe 程序

aaarticlea/png;base64,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" alt="" width="506" height="82" />

1.1 最小 cpp

int main(){}    // minimal cpp

  思考一:  为什么最小程序没有 return 语句?

1.2  Hello

#include <iostream>

int main()
{
std::cout << "Hello!\n";
}

  思考二:  \n 和 std::endl 的区别是什么?

1.3  函数

#include <iostream>

double Square(double x)
{
return x*x;
} void PrintSquare(double x)
{
std::cout << "The square of " << x << " is "<< Square(x) << '\n';
} int main()
{
PrintSquare(1.21);
}

思考三:  Square 有必要写成模板函数么?

2  类型、变量和运算

2.1  定义

声明 (declaration): a statement that introduces a name into the program. It specifies a type for the named entity

类型 (type): (为对象) 定义了一系列可能 值(value) 和一系列 操作(operations)

(value): a set of bits interpreted according to a type.

aaarticlea/png;base64,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" alt="" />

2.2  对象和变量

对象 (object):  some memory that holds a value of some type

变量 (variable):  a named object

2.3  初始化

  等号 "=" 属于 C 语言, C++ 中尽量用 {}-list

double d1 = 2.3;
double d2 {2.3}; complex<double> z = ;      // a complex number with double-precision floating-point scalars
complex<double> z2 {d1,d2};
complex<double> z3 = {,}; // the = is optional with {...}
vector<int> v {,,,,,}; // a vector of ints

c++11 的 auto

auto b = true;     // a bool
auto ch = 'x'; // a char
auto i = ; // an int
auto d = 1.2; // a double
auto z = sqrt(y); // z has the type of whatever sqrt(y) returns

尽量使用 auto,除非如下:

1) in a large scope where we want to make the type clearly visible to readers of our code.

2) be explicit about a variable’s range or precision (e.g., double rather than float ).

3  常量

3.1 const 和 constexpr

  const,意思是 “承诺不改变其值”,常用来指定 “接口” (interfaces), 这样 数据 可以传递给 函数 而本身不被修改,编译器通过 const 关键字来保证这种承诺的执行。

const int dmv = ;    // dmv is a named constant
int var = ; // var is not a constant
constexpr double max1 = 1.4∗Square(dmv); // OK if square(17) is a constant expression
constexpr double max2 = 1.4∗Square(var); // error : var is not a constant expression
const double max3 = 1.4∗Square(var); // OK, may be evaluated at run time

constexpr :meaning roughly ‘‘to be evaluated at compile time’’. This is used primarily to specify constants, to allow placement of data in memory where it is unlikely to be corrupted, and for performance.

double sum(const vector<double>&);    // sum will not modify its argument
vector<double> v {1.2, 3.4, 4.5}; // v is not a constant
const double s1 = sum(v); // OK: evaluated at run time
constexpr double s2 = sum(v); // error : sum(v) not constant expression

3.2  constexpr function

For a function to be usable in a constant expression, that is, in an expression that will be evaluated by the compiler, it must be defined constexpr

constexpr double Square(double x) { return x∗x; }

To be constexpr , a function must be rather simple: just a return -statement computing a value.

A constexpr function can be used for non-constant arguments, but when that is done the result is not a constant expression.

4  控制语句

4.1  if 语句

bool Accept()
{
cout << "Do you want to proceed (y or n)?\n"; // write question char answer = ;
cin >> answer; // read answer if(answer == 'y') return true;
return false;
}

4.2  switch 语句

bool Accept2()
{
cout << "Do you want to proceed (y or n)?\n"; // write question char answer = ;
cin >> answer; // read answer switch(answer) {
case 'y':
return true;
case 'n':
return false;
default:
cout << "I will take that for a no.\n";
return false;
}
}

4.3  while 语句

bool Accept3()
{
int tries = ;
while(tries < ){
cout << "Do you want to proceed (y or n)?\n"; // write question
char answer = ;
cin >> answer; // read answer switch(answer) {
case 'y':
return true;
case 'n':
return false;
default:
cout << "Sorry, I don't understand that.\n";
++tries; // increment
}
}
cout << "I'll take that for a no.\n";
return false;
}

5  指针和数组

5.1  [] 和 *

[ ] 等于 ‘‘array of’’, ∗ 意思是 ‘‘pointer to’’

char v[];   // array of 6 characters
char∗ p; // pointer to character

前缀 ∗ 是取内容, 前缀 & 是取地址

char∗ p = &v[];     // p points to v’s fourth element
char x = ∗p; // *p is the object that p points to

  aaarticlea/png;base64,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" alt="" />

T a[n];   // T[n]: array of n Ts
T∗ p;    // T*: pointer to T
T& r;    // T&: reference to T
T f(A);  // T(A): function taking an argument of type A returning a result of type T

5.2  拷贝和输出

拷贝一个数组的元素到另一个数组

void CopyFct()
{
int v1[] = {, , , , , , , , , };
int v2[]; for(auto i=; i!=; ++i) // copy elements
v2[i] = v1[i];
}

将 v 中每一个元素的值 , 拷贝给 x 并显示其输出。

void Print()
{
int v[] = {, , , , , , , , , }; for(auto x : v)          // range-for 的形式一
std::cout << x << '\n';   // for every element of v, from the first to the last, place a copy in x and print it for(auto x : {, , , , })
std::cout << x << '\n';
}

5.3  引用

void Increment()
{
int v[] = {, , , , , , , , , }; for(auto &x : v)  // range-for 的形式二
++x;
}

后缀 & 意思是 ‘‘reference to’’,类似指针,但却不需要一个前缀 ∗ 来访问值

// count the number of occurrences of x in p[]
// p is assumed to point to a zero-ter minated array of char (or to nothing)
int CountX(char* p, char x)
{
if(p==nullptr) return ;
int count = ;
for(; *p!=; ++p)
if(*p == x)
++count;
return count;
}

其中,nullptr 参见博文 C++11 之 nullptr

参考资料:

<C++ Programming Language_4th>

C++ 之 基础回顾(一)的更多相关文章

  1. [C#] C# 基础回顾 - 匿名方法

    C# 基础回顾 - 匿名方法 目录 简介 匿名方法的参数使用范围 委托示例 简介 在 C# 2.0 之前的版本中,我们创建委托的唯一形式 -- 命名方法. 而 C# 2.0 -- 引进了匿名方法,在 ...

  2. Javascript基础回顾 之(三) 面向对象

    本来是要继续由浅入深表达式系列最后一篇的,但是最近团队突然就忙起来了,从来没有过的忙!不过喜欢表达式的朋友请放心,已经在写了:) 在工作当中发现大家对Javascript的一些基本原理普遍存在这里或者 ...

  3. Javascript基础回顾 之(二) 作用域

    本来是要继续由浅入深表达式系列最后一篇的,但是最近团队突然就忙起来了,从来没有过的忙!不过喜欢表达式的朋友请放心,已经在写了:) 在工作当中发现大家对Javascript的一些基本原理普遍存在这里或者 ...

  4. Javascript基础回顾 之(一) 类型

    本来是要继续由浅入深表达式系列最后一篇的,但是最近团队突然就忙起来了,从来没有过的忙!不过喜欢表达式的朋友请放心,已经在写了:) 在工作当中发现大家对Javascript的一些基本原理普遍存在这里或者 ...

  5. JavaScript 基础回顾——对象

    JavaScript是基于对象的解释性语言,全部数据都是对象.在 JavaScript 中并没有 class 的概念,但是可以通过对象和类的模拟来实现面向对象编程. 1.对象 在JavaScript中 ...

  6. 四、Android学习第四天——JAVA基础回顾(转)

    (转自:http://wenku.baidu.com/view/af39b3164431b90d6c85c72f.html) 四.Android学习第四天——JAVA基础回顾 这才学习Android的 ...

  7. 1、java基础回顾与加强

    一.    基础回顾 1   集合 1.1  集合的类型与各自的特性 ---|Collection: 单列集合 ---|List: 有存储顺序, 可重复 ---|ArrayList:    数组实现, ...

  8. C#基础回顾:正则表达式

    C#基础回顾:正则表达式 写在前面:本文根据笔者的学习体会结合相关书籍资料对正则表达式的语法和使用(C#)进行基本的介绍.适用于初学者. 摘要:正则表达式(Regular Expressions),相 ...

  9. 【Spring学习】【Java基础回顾-数据类型】

    Java基础回顾过程中,之前对于Java相关基础知识都是从这个人的博客看一些,那边的内容看一下,觉得不够系统化,决定用xmind脑图的形式,将Java基础知识回顾的作为一个系列,当前正在做的会包含: ...

  10. JavaScript基础回顾一(类型、值和变量)

    请看代码并思考输出结果 var scope = 'global'; function f(){ console.log(scope); var scope = 'local'; console.log ...

随机推荐

  1. Java常用工具类之IO流工具类

    package com.wazn.learn.util; import java.io.Closeable; import java.io.IOException; /** * IO流工具类 * * ...

  2. spring杂碎

    spring优点 方便解耦,简化开发 Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理 AOP编程的支持 Spring提供面向切面编程,可以方便的实现对程序进行权限拦 ...

  3. Node.js后台开发初体验

    Node.js是什么 Node.js是一个Javascript运行环境(runtime),发布于2009年5月,由Ryan Dahl开发,实质时对Chrome V8引擎进行了封装 Node.js安装 ...

  4. 又见Python<2>:如何安装第三方库(Windows)

    使用python进行数据分析或者数据处理时,往往需要使用一些库,而使用库之前必须安装它.Anaconda内置了很多常用的第三方库,可以满足绝大部分需求,比如numpy.pandas.matplotli ...

  5. codeforces 220 C. Game on Tree

    题目链接 codeforces 220 C. Game on Tree 题解 对于 1节点一定要选的 发现对于每个节点,被覆盖切选中其节点的概率为祖先个数分之一,也就是深度分之一 代码 #includ ...

  6. zoj 3261 逆向并查集+离线处理

    题意:给出一些点,每个点有权值,然后有一些边,相连.无向的.然后有一些操作 链接:点我 query a.表示从a出发的能到达的所有点权值最大的点的编号(相同取编号最小,而且权值要比自己大) desto ...

  7. 腾讯通消息webSDK踩坑

    1.腾讯通提供一个通过http协议的接口,可用于发送消息,公告等功能,要使用其功能首先要开启RTX_HTTPServer服务. 2.阅读文档http://rtx.tencent.com/sdk/,为了 ...

  8. SCOJ 4423: Necklace polya

    4423: Necklace 题目连接: http://acm.scu.edu.cn/soj/problem.action?id=4423 Description baihacker bought a ...

  9. 安装与使用adb

    ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" ...

  10. 为什么要使用netty

    选择Netty的理由在开始本节之前,我先讲一个亲身经历的故事:曾经有两个项目组同时用到了NIO编程技术,一个项目组选择自己开发NIO服务端,直接使用JDK原生的API,结果2个多月过去了,他们的NIO ...