以下实例使用嵌套 for 循环来输出菱形：

#include <iostream>
#include <math.h>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    //外层循环控制行、换行
    //内层循环控制列、列的图形
    //中分的三角菱形
    //定义半菱形高度，即定义了菱形的大小
    int n ;
    cout<<"请输入半菱形高度"<<endl;
    cin >> n; 
    //上半部分居中正三角n行
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - i -1; j++)
        {
            cout<<" ";
        }
        for (int j = 0; j <= 2 * i; j++)
        {
            //每行第一个和最后一个外打印星号，其余打印空格，做成空心效果，下半部分相同
            if (j == 0 or j == 2 * i)
                cout<<"*";
            else
                cout<<" ";
        }
        cout<<endl;
    }

    //下半部分居中倒三角n-1行
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j <= i; j++)
        {
            cout<<" ";
        }
        for (int j = 0; j <= 2 * ( n - i - 2 ); j++)
        {
            if (j == 0 or j == 2 * ( n - i - 2 ))
                cout<<"*";
            else
                cout<<" ";
        }
        cout<<endl;
    }
    return 0;
}

测试输出结果：

请输入半菱形高度
5
    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

任何数异或 ^0 得到的值不变:

a^0 = a

任何数异或同一个数两次得到的值不变:

a^b^b = a

C++ 中的 --> 操作符?

以下代码中我们设置了一个 x 自减的条件运算符代码，在 x 的进行自减运算前，会先使用比较符号 > 与右边表达式 0 进行比较，然后返回结果再进行自减运算：

while (x --> 0)

// 相等于以下代码
while( (x--) > 0 )
// 把两个运算符分开更好理解了

while (x-- > 0)

实例 1：输出 0 到 9 的 整数

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) 
    {
        printf("%d ", x);
    }
}

输出结果：

9 8 7 6 5 4 3 2 1 0

实例 2: 输出 大于 0 小于 10 的偶数

#include <stdio.h>
int main()
{

    int x = 10;

    while( 0 <---- x )
    {
       printf("%d ", x);
    }
}

输出结果：

8 6 4 2

实例 3

#include <stdio.h>
int main()
{
    int x = 100;

    while( 0 <-------------------- x )
    {
       printf("%d ", x);
    }
}

输出结果：

90 80 70 60 50 40 30 20 10

除法/和求模%若两个操作数是正数，则除法的结果是正数，求模的结果也是正数若两个操作数是负数，则除法的结果是正数，求模的结果是负数若只有一个操作数是负数，则除法和求模的结果取决于机器，除法可以确定结果是负数逻辑与和逻辑或操作符总是先计算其左操作数，然后再计算其右操作数，只有在仅靠左操作数的值无法确定该逻辑表达式的结果时，才会求解其右操作数区分 if(i<j<k) 和 if(i<j && j<k)第一个i<j或者为0或者为1，只要k大于1，表达式就为true第二个必须i<j且j<k表达式才为true区分 if(val) 和 if(val == true)第一个只要val非零则表达式为true,val为0则表达式为false第二个只有val为1表达式为true,val非1则表达式为false

int val = 2;
if(val==true){              //不会进入if
  cout<<"val==true"<<endl;
}

多个赋值操作符中，各对象必须具有相同的数据类型，或者具有可转换为同一类型的数据类型。

int ival; int *pval;
ival = pval = 0;  //error 尽管ival和pval都可以赋值为0
string s1,s2;
s1 = s2 = "OK"    //ok

如果指针指向不是用new分配的内存地址，则在该指针上使用delete是不合法的。

通常编译器不能断定一个指针是否指向动态对象，因此尽管这样做是错误的，但在大部分编译器上仍能运行通过，但是会产生运行时错误。整形提升

对于所有比int小的整形(char, signed char, unsigned char, short, unsigned short)，如过该类型所有可能值都包含在int中，他们会被提升为int型，否则，他们将被提升为unsigned int。

对于包含signed和unsigned int型的表达式，表达式中的signed型整数会被转换为unsigned型。

int i = -5;
unsigned int ii = 1;
cout<<(i>ii)<<endl;   //输出1，非常有趣的结果 原因是int型的i转换为unsigned int型
short i = -5;
unsigned short ii = 1;
cout<<(i>ii)<<endl;  //输出0 比较时short和unsigned short都提升为int型

关于逻辑运算符 && ，|| 的巧用方式

逻辑与 &&

&& 会先判断左边的值是否为真。

如果为假，那么整个表达式毫无疑问也为假。

如果为真，那就还需要判断右值，才能知道整个式子的值。

这个时候判断右值的过程就起了一个if的作用，可以利用这个过程判断右边表达式是否为真。

下面代码：

/*不用任何循环语句，不用if，来实现1+2+3+...+10的值*/
#include <iostream>
using namespace std;

int add(int c)
{
    int a=0;
    c&&(a=add(c-1));//递归循环，直到传入c的值为0则结束循环
    cout<<c+a<<endl;
    return c+a;
}
int main()
{ 
    add(10);
    return 0;
}

逻辑或 ||

其实与上面的逻辑与 && 大同小异。

都是先判断左边是否为真，再来考虑右边。

因为逻辑与 || 只需要左边为真，那么整个表达式就有值，就不会再去算右边的值了。

所以我们加个 ! 让 c 值为假时，!c 才为真，这样的话逻辑与 || 还需要判断右边的表达式才能计算出整个表达式的值。

(!c)||(a=add(c-1));

这样就达到了和用逻辑与&&时一样的目的。

代码：

/*不用任何循环语句，不用if，来实现1+2+3+...+10的值*/
#include <iostream>
using namespace std;

int add(int c)
{
    int a=0;
    (!c)||(a=add(c-1));//递归循环，直到传入c的值为0，(!c)就为真，结束循环
    cout<<c+a<<endl;
    return c+a;
}
int main()
{ 
    add(10);
    return 0;
}